死侍 1-3
注：本片不适合公共场合观看
{{ .PluginName }} 管理界面
` ``` 5. **可选实现**: Web路由是**可选功能**，只有需要自定义HTTP接口的插件才需要实现 ### 2. Service层过滤控制详解 #### 构造函数选择 ```go // 标准插件构造函数（默认启用Service层过滤） func NewStandardPlugin() *StandardPlugin { return &StandardPlugin{ BaseAsyncPlugin: plugin.NewBaseAsyncPlugin("standard", 3), // 默认skipServiceFilter=false } } // 磁力搜索插件构造函数（跳过Service层过滤） func NewMagnetPlugin() *MagnetPlugin { return &MagnetPlugin{ BaseAsyncPlugin: plugin.NewBaseAsyncPluginWithFilter("magnet", 4, true), // skipServiceFilter=true } } ``` #### 实际应用示例 **ThePirateBay插件示例**: ```go // thepiratebay插件的实际实现 func NewThePirateBayPlugin() *ThePirateBayPlugin { return &ThePirateBayPlugin{ BaseAsyncPlugin: plugin.NewBaseAsyncPluginWithFilter("thepiratebay", 4, true), // 跳过Service层过滤 optimizedClient: createOptimizedHTTPClient(), } } func (p *ThePirateBayPlugin) searchImpl(client *http.Client, keyword string, ext map[string]interface{}) ([]model.SearchResult, error) { // 支持英文搜索优化 searchKeyword := keyword if ext != nil { if titleEn, exists := ext["title_en"]; exists { if titleEnStr, ok := titleEn.(string); ok && titleEnStr != "" { searchKeyword = titleEnStr } } } // 获取搜索结果 allResults := p.fetchAllResults(client, searchKeyword) // 标题格式优化：将'.'替换为空格，提高关键词匹配准确度 for i := range allResults { allResults[i].Title = strings.ReplaceAll(allResults[i].Title, ".", " ") } // 插件层过滤（使用处理后的搜索关键词） filteredResults := plugin.FilterResultsByKeyword(allResults, searchKeyword) return filteredResults, nil // 注意：Service层会通过SkipServiceFilter()方法跳过二次过滤 } ``` #### 过滤策略对比 | 过滤类型 | 标准插件 | 磁力搜索插件 | |----------|----------|--------------| | **插件层过滤** | ✅ 使用原始关键词 | ✅ 使用searchKeyword（支持title_en） | | **Service层过滤** | ✅ 再次过滤 | ❌ 跳过过滤 | | **结果特点** | 精确匹配 | 宽泛搜索 | | **适用场景** | 中文网盘资源 | 英文磁力资源 | #### 动态过滤检测机制 Service层通过以下机制动态判断是否需要过滤： ```go // service/search_service.go 中的实现 func mergeResultsByType(...) { // 检查插件是否需要跳过Service层过滤 var skipKeywordFilter bool = false if result.UniqueID != "" && strings.Contains(result.UniqueID, "-") { parts := strings.SplitN(result.UniqueID, "-", 2) if len(parts) >= 1 { pluginName := parts[0] // 通过插件注册表动态获取过滤设置 if pluginInstance, exists := plugin.GetPluginByName(pluginName); exists { skipKeywordFilter = pluginInstance.SkipServiceFilter() } } } // 根据插件设置决定是否过滤 if !skipKeywordFilter && keyword != "" && !strings.Contains(strings.ToLower(title), lowerKeyword) { continue // 过滤掉不匹配的结果 } } ``` ### 2. 扩展参数处理 ```go // 支持的扩展参数示例 ext := map[string]interface{}{ "title_en": "English Title", // 英文标题 "is_all": true, // 全量搜索标志 "year": 2023, // 年份限制 "type": "movie", // 内容类型 } // 在插件中处理 func (p *MyPlugin) handleExtParams(ext map[string]interface{}) searchOptions { opts := searchOptions{} if titleEn, ok := ext["title_en"].(string); ok { opts.TitleEn = titleEn } if isAll, ok := ext["is_all"].(bool); ok { opts.IsAll = isAll } return opts } ``` ### 2. 缓存策略 ```go // 设置缓存TTL p.SetCacheTTL(2 * time.Hour) // 手动缓存更新 p.UpdateMainCache(cacheKey, results, ttl, true, keyword) ``` ### 3. 错误处理 ```go func (p *MyPlugin) searchImpl(client *http.Client, keyword string, ext map[string]interface{}) ([]model.SearchResult, error) { // 网络错误处理 resp, err := client.Get(url) if err != nil { return nil, fmt.Errorf("[%s] 网络请求失败: %w", p.Name(), err) } // HTTP状态码检查 if resp.StatusCode != 200 { return nil, fmt.Errorf("[%s] HTTP错误: %d", p.Name(), resp.StatusCode) } // JSON解析错误 - 推荐使用项目统一的JSON工具 body, err := io.ReadAll(resp.Body) if err != nil { return nil, fmt.Errorf("[%s] 读取响应失败: %w", p.Name(), err) } var apiResp APIResponse if err := json.Unmarshal(body, &apiResp); err != nil { return nil, fmt.Errorf("[%s] JSON解析失败: %w", p.Name(), err) } // 业务逻辑错误 if apiResp.Code != 0 { return nil, fmt.Errorf("[%s] API错误: %s", p.Name(), apiResp.Message) } return results, nil } ``` ## 性能优化 ### 1. HTTP客户端优化 ```go // 使用连接池 client := &http.Client{ Timeout: 30 * time.Second, Transport: &http.Transport{ MaxIdleConns: 100, MaxIdleConnsPerHost: 10, IdleConnTimeout: 90 * time.Second, }, } ``` ### 2. 内存优化 ```go // 预分配切片容量 results := make([]model.SearchResult, 0, expectedCount) // 及时释放大对象 defer func() { apiResp = APIResponse{} }() ``` ### 3. 并发控制 ```go // 使用插件内置的工作池，避免创建过多goroutine // BaseAsyncPlugin 已经提供了工作池管理 ``` ## 测试和调试 ### 1. 单元测试 ```go func TestMyPlugin_Search(t *testing.T) { plugin := &MyPlugin{ BaseAsyncPlugin: plugin.NewBaseAsyncPlugin("test", 3), } results, err := plugin.Search("测试关键词", nil) assert.NoError(t, err) assert.NotEmpty(t, results) } ``` ### 2. 集成测试 ```bash # 使用API测试插件 curl "http://localhost:8888/api/search?kw=测试&plugins=myplugin" ``` ### 3. 性能测试 ```bash # 使用压力测试脚本 python3 stress_test.py ``` ## 部署和配置 ### 1. 插件注册 确保在 `init()` 函数中注册插件： ```go func init() { p := &MyPlugin{ BaseAsyncPlugin: plugin.NewBaseAsyncPlugin("myplugin", 3), } plugin.RegisterGlobalPlugin(p) } ``` ### 2. 环境配置 ```bash # 异步插件配置 export ASYNC_PLUGIN_ENABLED=true export ASYNC_RESPONSE_TIMEOUT=4 export ASYNC_MAX_BACKGROUND_WORKERS=40 export ASYNC_MAX_BACKGROUND_TASKS=200 ``` ### 3. 生产部署注意事项 1. **资源限制**: 根据服务器配置调整工作池大小 2. **监控告警**: 监控插件响应时间和错误率 3. **日志管理**: 合理设置日志级别，避免日志过多 4. **缓存配置**: 根据数据更新频率调整缓存TTL ## 现有插件参考 ### 标准网盘搜索插件 - **jikepan** - 标准网盘插件，启用Service层过滤 - **pan666** - 标准网盘插件，启用Service层过滤 - **hunhepan** - 标准网盘插件，启用Service层过滤 - **pansearch** - 标准网盘插件，启用Service层过滤 - **qupansou** - 标准网盘插件，启用Service层过滤 - **panta** - 高质量网盘插件，启用Service层过滤 ### 特殊搜索插件 - **thepiratebay** - 磁力搜索插件，跳过Service层过滤，支持title_en参数，标题格式化处理 ## 插件开发最佳实践 ⭐ ### 核心原则 1. **命名规范**: 插件名使用小写字母和数字 2. **优先级设置**: 1-2为高优先级，3为标准，4-5为低优先级 3. **关键词过滤**: 使用 `FilterResultsByKeyword` 提高结果相关性 4. **缓存友好**: 合理设置缓存TTL，避免频繁请求 5. **资源清理**: 及时关闭连接和释放资源 6. **过滤策略**: 根据插件类型选择合适的Service层过滤策略 ### 必须实现的优化点 #### 1. Service层过滤策略选择 ⭐ 新功能 ```go // ✅ 磁力搜索插件 - 跳过Service层过滤 func NewMagnetSearchPlugin() *MagnetSearchPlugin { return &MagnetSearchPlugin{ BaseAsyncPlugin: plugin.NewBaseAsyncPluginWithFilter("magnet", 4, true), // skipServiceFilter=true } } // ✅ 标准网盘插件 - 启用Service层过滤 func NewPanSearchPlugin() *PanSearchPlugin { return &PanSearchPlugin{ BaseAsyncPlugin: plugin.NewBaseAsyncPlugin("pansearch", 3), // 默认skipServiceFilter=false } } ``` **选择指南**: - **跳过过滤** (`true`): 磁力搜索、英文资源、特殊格式标题、聚合搜索 - **启用过滤** (`false`): 网盘搜索、中文资源、API接口、标准格式标题 **注意事项**: - 跳过Service层过滤的插件**必须**在插件内部进行`FilterResultsByKeyword`过滤 - 插件层过滤使用的关键词应与实际搜索关键词一致（支持`title_en`等参数） - 标题格式化处理应在过滤之前进行（如将`"."` 替换为`" "`） #### 2. SearchResult字段设置规范 ⭐ 重要 ```go // ✅ 正确的SearchResult设置 result := model.SearchResult{ UniqueID: fmt.Sprintf("%s-%s", p.Name(), itemID), // 插件名-资源ID Title: title, // 资源标题 Content: description, // 资源描述 Links: downloadLinks, // 下载链接列表 Tags: tags, // 分类标签 Channel: "", // ⭐ 重要：插件搜索结果必须为空字符串 Datetime: time.Now(), // 发布时间 } // ❌ 错误的Channel设置 result.Channel = p.Name() // 不要设置为插件名！ ``` **Channel字段使用规则**: - **插件搜索结果**: `Channel` 必须为空字符串 `""` - **Telegram频道**: `Channel` 才设置为频道名称 - **目的**: 区分搜索来源，便于前端展示和后端统计 **Links字段处理规则** ⭐ 重要: - **必须有链接**: 系统会自动过滤掉 `Links` 为空或长度为0的结果 - **链接质量**: 确保返回的链接都是有效的网盘链接，避免返回无效链接 - **链接验证**: 建议使用 `isValidNetworkDriveURL()` 函数预先验证链接有效性 #### 2. HTTP请求最佳实践 ⭐ 重要 ```go // ✅ 正确的请求实现 func (p *MyPlugin) makeRequest(url string, client *http.Client) (*http.Response, error) { // 使用context控制超时 ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second) defer cancel() // 创建请求 req, err := http.NewRequestWithContext(ctx, "GET", url, nil) if err != nil { return nil, err } // 设置完整的请求头（避免反爬虫） req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36") req.Header.Set("Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8") req.Header.Set("Accept-Language", "zh-CN,zh;q=0.9,en;q=0.8") req.Header.Set("Connection", "keep-alive") req.Header.Set("Referer", "https://example.com/") // 使用重试机制 return p.doRequestWithRetry(req, client) } // ❌ 错误的简单实现 func (p *MyPlugin) badRequest(url string, client *http.Client) (*http.Response, error) { return client.Get(url) // 没有超时控制、没有请求头、没有重试 } ``` #### 2. 实现高级搜索接口 ⭐ 推荐 ```go // ✅ 推荐：实现两个方法 func (p *MyPlugin) Search(keyword string, ext map[string]interface{}) ([]model.SearchResult, error) { result, err := p.SearchWithResult(keyword, ext) if err != nil { return nil, err } return result.Results, nil } func (p *MyPlugin) SearchWithResult(keyword string, ext map[string]interface{}) (model.PluginSearchResult, error) { return p.AsyncSearchWithResult(keyword, p.searchImpl, p.MainCacheKey, ext) } ``` #### 3. 错误处理增强 ⭐ 重要 ```go // ✅ 详细的错误信息 if resp.StatusCode != 200 { return nil, fmt.Errorf("[%s] 请求失败，状态码: %d", p.Name(), resp.StatusCode) } // ✅ 包装外部错误 if err := json.NewDecoder(resp.Body).Decode(&data); err != nil { return nil, fmt.Errorf("[%s] JSON解析失败: %w", p.Name(), err) } ``` #### 4. 重试机制模板 ⭐ 复制可用 ```go func (p *MyPlugin) doRequestWithRetry(req *http.Request, client *http.Client) (*http.Response, error) { maxRetries := 3 var lastErr error for i := 0; i < maxRetries; i++ { if i > 0 { backoff := time.Duration(1<Gin Handler] B --> C[参数解析与验证
GET/POST处理] C --> D[参数预处理
规范化处理] D --> E[SearchService
主搜索服务] E --> F{源类型判断
sourceType} F -->|TG| G[并行TG搜索] F -->|Plugin| H[并行插件搜索] F -->|All| I[TG+插件并行搜索] I --> G I --> H %% TG搜索分支 G --> G1[生成TG缓存键
GenerateTGCacheKey] G1 --> G2{强制刷新?
forceRefresh} G2 -->|否| G3[检查二级缓存
EnhancedTwoLevelCache] G2 -->|是| G6[跳过缓存检查] G3 --> G4{缓存命中?} G4 -->|是| G5[缓存反序列化
直接返回结果] G4 -->|否| G6[执行TG频道搜索
多频道并行] G6 --> G7[HTML解析
链接提取] G7 --> G8[结果标准化] G8 --> G9[更新缓存
SetBothLevels] %% 插件搜索分支 - 详细的异步处理 H --> H1[生成插件缓存键
GeneratePluginCacheKey] H1 --> H2{强制刷新?
forceRefresh} H2 -->|否| H3[检查二级缓存
EnhancedTwoLevelCache] H2 -->|是| H6[跳过缓存检查] H3 --> H4{缓存命中?} H4 -->|是| H5[缓存反序列化
直接返回结果] H4 -->|否| H6[插件管理器调度
PluginManager] %% 异步插件详细流程 H6 --> H7[异步插件初始化
SetMainCacheKey] H7 --> H8[工作池任务提交
WorkerPool] %% 双级超时机制的并行处理 H8 --> H9{异步并行处理} %% 快速响应分支 (4秒) H9 --> H10[短超时处理
4秒快速响应] H10 --> H11[HTTP请求
短超时模式] H11 --> H12[部分结果解析
快速过滤] H12 --> H13[部分结果缓存
isFinal=false] H13 --> H14[立即返回
部分结果给用户] %% 持续处理分支 (30秒) H9 --> H15[长超时后台处理
最长30秒持续] H15 --> H16[HTTP请求
长超时模式] H16 --> H17[完整结果解析
深度过滤] H17 --> H18[结果去重合并
最终处理] H18 --> H19[完整结果缓存
isFinal=true] H19 --> H20[主缓存异步更新
DelayedBatchWrite] %% 结果合并处理 G5 --> J[结果合并
mergeSearchResults] G9 --> J H5 --> J H14 --> J J --> K[智能排序算法
时间+关键词+插件等级] K --> L[结果过滤
高质量结果筛选] L --> M[网盘类型分组
mergeResultsByType] M --> N{结果类型
resultType} N -->|merged_by_type| O[返回分组结果] N -->|results| P[返回原始结果] N -->|all| Q[返回完整结果] O --> R[JSON响应] P --> R Q --> R R --> S[用户] %% 后台持续更新（不影响用户响应） H20 --> T[后台缓存完善
下次请求更完整] T -.-> U[持续优化
用户体验] %% 缓存系统 subgraph Cache[二级缓存系统] CA[分片内存缓存
LRU + 原子操作] CB[分片磁盘缓存
GOB序列化] CC[智能缓存写入管理器
DelayedBatchWriteManager] CD[全局缓冲区管理器
BufferByPlugin策略] end G3 -.-> CA H3 -.-> CA CA -.-> CB G9 -.-> CC H13 -.-> CC H20 -.-> CC CC -.-> CD %% 样式定义 classDef cacheNode fill:#e1f5fe,stroke:#01579b,stroke-width:2px classDef pluginNode fill:#f3e5f5,stroke:#4a148c,stroke-width:2px classDef searchNode fill:#e8f5e8,stroke:#1b5e20,stroke-width:2px classDef fastResponse fill:#fff3e0,stroke:#e65100,stroke-width:2px classDef slowProcess fill:#fce4ec,stroke:#880e4f,stroke-width:2px classDef processNode fill:#f5f5f5,stroke:#424242,stroke-width:2px class G3,H3,G5,H5,G9,H13,H20,CA,CB,CC,CD cacheNode class H6,H7,H8 pluginNode class G6,G7,G8 searchNode class H10,H11,H12,H13,H14 fastResponse class H15,H16,H17,H18,H19,H20,T slowProcess class D,J,K,L,M processNode ``` ### 2.2 异步插件工作流程 ```mermaid sequenceDiagram participant U as 用户 participant API as API Handler participant S as SearchService participant SP as searchPlugins函数 participant C as 二级缓存系统 participant PM as PluginManager participant P as AsyncPlugin participant WP as WorkerPool participant BWM as BatchWriteManager participant EXT as 外部API %% 请求处理阶段 U->>API: 🔍 搜索请求 (kw=关键词) API->>API: 参数解析与验证 API->>API: 参数预处理规范化 API->>S: Search(req.Keyword, ...) %% 并行搜索启动 Note over S: 🚀 并行启动TG和插件搜索 S->>SP: searchPlugins(keyword, plugins, ...) %% 缓存检查阶段 SP->>SP: 生成插件缓存键 SP->>SP: 检查forceRefresh标志 alt forceRefresh = false SP->>C: 🔍 Get(cacheKey) alt 缓存命中 C-->>SP: ✅ 返回缓存数据 SP->>SP: 反序列化结果 SP-->>S: 🎯 返回缓存结果 (<10ms) S-->>U: ⚡ 极速响应 else 缓存未命中 Note over SP: 🚨 执行异步插件搜索 SP->>PM: 获取可用插件列表 SP->>PM: 过滤指定插件 end else forceRefresh = true Note over SP: 🔄 跳过缓存，强制搜索 SP->>PM: 获取可用插件列表 SP->>PM: 过滤指定插件 end %% 异步搜索初始化 PM->>P: 🎯 设置关键词和缓存键 P->>P: SetMainCacheKey(cacheKey) P->>P: SetCurrentKeyword(keyword) P->>P: 注入缓存更新函数 %% 🚀 异步插件的精髓：双级超时并行机制 Note over P,EXT: 🔥 异步插件精髓：快速响应 + 持续处理 P->>WP: 🚀 提交异步任务到工作池 %% 快速响应路径 (4秒) par 🚀 快速响应路径 (4秒) Note over WP,EXT: ⚡ 第一阶段：快速响应用户 WP->>EXT: HTTP请求 (短超时 4秒) EXT-->>WP: 部分响应数据 WP->>P: 🔍 解析部分结果 P->>P: 快速过滤和标准化 P->>P: 📝 记录日志: 初始缓存创建 %% 部分结果立即缓存和返回 P->>BWM: 🗄️ 异步缓存更新 (isFinal=false) Note over BWM: 部分结果缓存，不等待写入完成 P-->>SP: 📤 部分结果立即返回 SP-->>S: 🎯 部分结果 (isFinal=false) S->>S: 与TG结果合并 S-->>U: ⚡ 快速响应 (~4秒) and 🔄 持续处理路径 (最长30秒) Note over WP,EXT: 🔄 第二阶段：后台持续完善 WP->>EXT: 继续HTTP请求 (长超时 30秒) EXT-->>WP: 完整响应数据 WP->>P: 🔍 解析完整结果 P->>P: 深度过滤和去重 P->>P: 结果质量评估 P->>P: 📝 记录日志: 缓存更新完成 %% 完整结果的主缓存更新 P->>BWM: 🗄️ 主缓存更新 (isFinal=true) Note over BWM: 完整结果写入，高优先级 BWM->>BWM: 🧠 智能缓存写入策略 BWM->>BWM: 🗂️ 全局缓冲区管理 BWM->>C: 📀 批量写入磁盘缓存 Note over C: 🎯 下次同样请求将获得完整结果 end %% 缓存系统内部处理 C->>C: ⚡ 立即更新内存缓存 C->>C: 📀 延迟批量更新磁盘缓存 C->>C: 🧹 自动清理过期缓存 %% 持续优化标注 Note over U,EXT: 💡 异步插件核心价值 Note over U,EXT: ✅ 用户获得快速响应 (4秒内) Note over U,EXT: ✅ 系统持续完善结果 (30秒内) Note over U,EXT: ✅ 下次访问获得完整数据 (<100ms) Note over U,EXT: 🔄 完美平衡：速度 vs 完整性 ``` ### 2.3 核心组件 #### 2.3.1 HTTP服务层 (`api/`) - **router.go**: 路由配置 - **handler.go**: 请求处理逻辑 - **middleware.go**: 中间件（日志、CORS等） #### 2.3.2 搜索服务层 (`service/`) - **search_service.go**: 核心搜索逻辑，结果合并 #### 2.3.3 插件系统层 (`plugin/`) - **plugin.go**: 插件接口定义 - **baseasyncplugin.go**: 异步插件基类 - **各插件目录**: jikepan、pan666、hunhepan等 #### 2.3.4 工具层 (`util/`) - **cache/**: 二级缓存系统实现 - **pool/**: 工作池实现 - **其他工具**: HTTP客户端、解析工具等 --- ## 3. 异步插件系统 ### 3.1 设计理念 异步插件系统解决传统同步搜索响应慢的问题，采用"尽快响应，持续处理"策略： - **4秒短超时**: 快速返回部分结果（`isFinal=false`） - **30秒长超时**: 后台继续处理，获得完整结果（`isFinal=true`） - **主动缓存更新**: 完整结果自动更新主缓存，下次访问更快 ### 3.2 插件接口实现 基于`plugin/plugin.go`的实际接口： ```go type AsyncSearchPlugin interface { Name() string Priority() int AsyncSearch(keyword string, searchFunc func(*http.Client, string, map[string]interface{}) ([]model.SearchResult, error), mainCacheKey string, ext map[string]interface{}) ([]model.SearchResult, error) SetMainCacheKey(key string) SetCurrentKeyword(keyword string) Search(keyword string, ext map[string]interface{}) ([]model.SearchResult, error) } ``` ### 3.3 基础插件类 `plugin/baseasyncplugin.go`提供通用功能： ```go type BaseAsyncPlugin struct { name string priority int cacheTTL time.Duration mainCacheKey string currentKeyword string // 用于日志显示 httpClient *http.Client mainCacheUpdater func(string, []model.SearchResult, time.Duration, bool, string) error } ``` ### 3.4 已实现插件列表 当前系统包含以下插件（基于`main.go`的导入）： - **hdr4k** - **hunhepan** - **jikepan** - **pan666** - **pansearch** - **panta** - **qupansou** - **susu** - **panyq** - **xuexizhinan** ### 3.5 插件注册机制 ```go // 全局插件注册表（plugin/plugin.go） var globalRegistry = make(map[string]AsyncSearchPlugin) // 插件通过init()函数自动注册 func init() { p := &MyPlugin{ BaseAsyncPlugin: plugin.NewBaseAsyncPlugin("myplugin", 3), } plugin.RegisterGlobalPlugin(p) } ``` --- ## 4. 二级缓存系统 ### 4.1 实现架构 基于`util/cache/`目录的实际实现： - **enhanced_two_level_cache.go**: 二级缓存主入口 - **sharded_memory_cache.go**: 分片内存缓存（LRU+原子操作） - **sharded_disk_cache.go**: 分片磁盘缓存 - **serializer.go**: GOB序列化器 - **cache_key.go**: 缓存键生成和管理 ### 4.2 分片缓存设计 #### 4.2.1 内存缓存分片 ```go // 基于CPU核心数的动态分片 type ShardedMemoryCache struct { shards []*MemoryCacheShard shardMask uint32 } // 每个分片独立锁，减少竞争 type MemoryCacheShard struct { data map[string]*CacheItem lock sync.RWMutex } ``` #### 4.2.2 磁盘缓存分片 ```go // 磁盘缓存同样采用分片设计 type ShardedDiskCache struct { shards []*DiskCacheShard shardMask uint32 basePath string } ``` ### 4.3 缓存读写策略 #### 4.3.1 读取流程 1. **内存优先**: 先检查分片内存缓存 2. **磁盘回源**: 内存未命中时读取磁盘缓存 3. **异步加载**: 磁盘命中后异步加载到内存 #### 4.3.2 写入流程 1. **智能写入策略**: 立即更新内存缓存，延迟批量写入磁盘 2. **DelayedBatchWriteManager**: 智能缓存写入管理器，支持immediate和hybrid两种策略 3. **原子操作**: 内存缓存使用原子操作 4. **GOB序列化**: 磁盘存储使用GOB格式 5. **数据安全保障**: 程序终止时自动保存所有待写入数据，防止数据丢失 ### 4.4 缓存键策略 `cache_key.go`实现了智能缓存键生成： ```go // TG搜索和插件搜索使用不同的缓存键前缀 func GenerateTGCacheKey(keyword string, channels []string) string func GeneratePluginCacheKey(keyword string, plugins []string) string ``` **优势**: - 独立更新：TG和插件缓存互不影响 - 提高命中率：精确的键匹配 - 并发安全：分片设计减少锁竞争 ### 4.5 序列化性能 使用GOB序列化（`serializer.go`）的实际优势： - **性能**: 比JSON序列化快约30% - **体积**: 比JSON小约20% - **兼容**: Go原生支持，无外部依赖 --- ## 5. 核心组件实现 ### 5.1 工作池系统 (`util/pool/`) #### 5.1.1 worker_pool.go 实现 - **批量任务处理**: `ExecuteBatchWithTimeout`方法 - **超时控制**: 支持任务级别的超时设置 - **并发限制**: 控制最大工作者数量 #### 5.1.2 object_pool.go 实现 - **对象复用**: 减少内存分配和GC压力 - **线程安全**: 支持并发访问 ### 5.2 HTTP服务配置 #### 5.2.1 服务器优化（基于config/config.go） ```go // 自动计算HTTP连接数，防止资源耗尽 func getHTTPMaxConns() int { cpuCount := runtime.NumCPU() maxConns := cpuCount * 25 // 保守配置 if maxConns < 100 { maxConns = 100 } if maxConns > 500 { maxConns = 500 // 限制最大值 } return maxConns } ``` #### 5.2.2 连接池配置（基于util/http_util.go） ```go // HTTP客户端优化配置 transport := &http.Transport{ MaxIdleConns: 100, MaxIdleConnsPerHost: 10, IdleConnTimeout: 90 * time.Second, } ``` ### 5.3 结果处理系统 #### 5.3.1 智能排序算法（service/search_service.go） PanSou 采用多维度综合评分排序算法，确保高质量结果优先展示： **评分公式**: ``` 总得分 = 插件得分(1000/500/0/-200) + 时间得分(最高500) + 关键词得分(最高420) ``` **权重分配**: - 🥇 **插件等级**: ~52% (主导因素) - 等级1(1000分) > 等级2(500分) > 等级3(0分) - 🥈 **关键词匹配**: ~22% (重要因素) - "合集"(420分) > "系列"(350分) > "全"(280分) - 🥉 **时间新鲜度**: ~26% (重要因素) - 1天内(500分) > 3天内(400分) > 1周内(300分) **关键优化**: - **缓存性能**: 跳过空结果和重复数据的缓存更新，减少70%无效操作 - **排序稳定性**: 修复map遍历随机性问题，确保merged_by_type保持排序 - **插件管理**: 启动时按优先级排序显示已加载插件，便于监控 #### 5.3.2 结果合并（mergeSearchResults函数） - **去重合并**: 基于UniqueID去重 - **完整性选择**: 选择更完整的结果保留 - **增量更新**: 新结果与缓存结果智能合并 ### 5.4 网盘类型识别 支持自动识别的网盘类型（共12种）： - 百度网盘、阿里云盘、夸克网盘、天翼云盘 - UC网盘、移动云盘、115网盘、PikPak - 迅雷网盘、123网盘、磁力链接、电驴链接 --- ## 6. 智能排序算法详解 ### 6.1 算法概述 PanSou 搜索引擎采用多维度综合评分排序算法，确保用户能够优先看到最相关、最新、最高质量的搜索结果。 #### 6.1.1 核心设计理念 1. **质量优先**：高等级插件的结果优先展示 2. **时效性重要**：新发布的资源获得更高权重 3. **相关性保证**：关键词匹配度影响排序 4. **用户体验**：最终排序结果保持稳定性 #### 6.1.2 排序流程 ```mermaid graph TD A[搜索请求] --> B[获取搜索结果 allResults] B --> C[sortResultsByTimeAndKeywords] C --> D[为每个结果计算得分] D --> E[时间得分
最高500分] D --> F[关键词得分
最高420分] D --> G[插件得分
等级1=1000分
等级2=500分
等级3=0分] E --> H[总得分 = 时间得分 + 关键词得分 + 插件得分] F --> H G --> H H --> I[按总得分降序排序] I --> J[mergeResultsByType] J --> K[按原始顺序收集唯一链接
保持排序不被破坏] K --> L[按类型分组
生成merged_by_type] L --> M[返回最终结果] ``` ### 6.2 评分算法详解 #### 6.2.1 核心公式 ``` 总得分 = 时间得分 + 关键词得分 + 插件得分 ``` #### 6.2.2 时间得分 (Time Score) 时间得分反映资源的新鲜度，**最高 500 分**： | 时间范围 | 得分 | 说明 | |---------|------|------| | ≤ 1天 | 500 | 最新资源，最高优先级 | | ≤ 3天 | 400 | 非常新的资源 | | ≤ 1周 | 300 | 较新资源 | | ≤ 1月 | 200 | 相对较新 | | ≤ 3月 | 100 | 中等新鲜度 | | ≤ 1年 | 50 | 较旧资源 | | > 1年 | 20 | 旧资源 | | 无日期 | 0 | 未知时间 | #### 6.2.3 关键词得分 (Keyword Score) 关键词得分基于搜索词在标题中的匹配情况，**最高 420 分**： | 优先关键词 | 得分 | 说明 | |-----------|------|------| | "合集" | 420 | 最高优先级 | | "系列" | 350 | 高优先级 | | "全" | 280 | 中高优先级 | | "完" | 210 | 中等优先级 | | "最新" | 140 | 较低优先级 | | "附" | 70 | 低优先级 | | 无匹配 | 0 | 无加分 | #### 6.2.4 插件得分 (Plugin Score) 插件得分基于数据源的质量等级，体现资源可靠性： | 插件等级 | 得分 | 说明 | |---------|------|------| | 等级1 | 1000 | 顶级数据源 | | 等级2 | 500 | 优质数据源 | | 等级3 | 0 | 普通数据源 | | 等级4 | -200 | 低质量数据源 | ### 6.3 权重分析与实际效果 #### 6.3.1 权重分配 | 维度 | 最高分值 | 权重占比 | 影响说明 | |------|---------|---------|----------| | 插件等级 | 1000 | ~52% | **主导因素**，决定基础排序 | | 关键词匹配 | 420 | ~22% | **重要因素**，优先关键词显著加分 | | 时间新鲜度 | 500 | ~26% | **重要因素**，同等级内排序关键 | #### 6.3.2 实际排序示例 | 场景 | 插件等级 | 时间 | 关键词 | 总分 | 排序 | |------|---------|------|--------|------|------| | 等级1 + 1天内 + "合集" | 1000 | 500 | 420 | **1920** | 🥇 第1 | | 等级1 + 1天内 + "系列" | 1000 | 500 | 350 | **1850** | 🥈 第2 | | 等级1 + 1月内 + "合集" | 1000 | 200 | 420 | **1620** | 🥉 第3 | | 等级2 + 1天内 + "合集" | 500 | 500 | 420 | **1420** | 第4 | | 等级1 + 1天内 + 无关键词 | 1000 | 500 | 0 | **1500** | 第5 | --- ## 7. API接口设计 ### 7.1 核心接口实现（基于api/handler.go） #### 7.1.1 搜索接口 ``` POST /api/search GET /api/search ``` **核心参数**: - `kw`: 搜索关键词（必填） - `channels`: TG频道列表 - `plugins`: 插件列表 - `cloud_types`: 网盘类型过滤 - `ext`: 扩展参数（JSON格式） - `refresh`: 强制刷新缓存 - `res`: 返回格式（merge/all/results） - `src`: 数据源（all/tg/plugin） #### 7.1.2 健康检查接口 ``` GET /api/health ``` 返回系统状态和已注册插件信息。 ### 6.2 中间件系统（api/middleware.go） - **日志中间件**: 记录请求响应，支持URL解码显示 - **CORS中间件**: 跨域请求支持 - **错误处理**: 统一错误响应格式 ### 6.3 扩展参数系统 通过`ext`参数支持插件特定选项： ```json { "title_en": "English Title", "is_all": true, "year": 2023 } ``` --- ## 8. 认证系统设计 ### 8.1 系统概述 PanSou认证系统是一个可选的安全访问控制模块，基于JWT（JSON Web Token）标准实现。该系统设计目标是在不影响现有用户的前提下，为需要私有部署的用户提供灵活的认证功能。 #### 8.1.1 核心特性 - **可选性**: 默认关闭，通过环境变量`AUTH_ENABLED`启用 - **无状态**: 基于JWT，无需session存储 - **标准化**: 采用RFC 7519 JWT标准 - **灵活性**: 支持多用户配置 - **安全性**: Token自动过期，防止长期有效性风险 ### 8.2 认证架构 #### 8.2.1 认证流程 ```mermaid sequenceDiagram participant U as 用户 participant F as 前端 participant M as 认证中间件 participant A as 认证接口 participant S as 搜索服务 Note over U,S: 初始访问阶段 U->>F: 访问应用 F->>F: 检查localStorage中的token alt token不存在或无效 F->>U: 显示登录窗口 U->>F: 输入账号密码 F->>A: POST /api/auth/login A->>A: 验证账号密码 A->>A: 生成JWT Token A-->>F: 返回Token F->>F: 存储Token到localStorage F->>U: 关闭登录窗口 end Note over U,S: API调用阶段 U->>F: 发起搜索请求 F->>F: axios拦截器添加Authorization头 F->>M: GET/POST /api/search + Token M->>M: 验证Token有效性 alt Token有效 M->>S: 转发请求 S-->>M: 返回搜索结果 M-->>F: 返回响应 F-->>U: 显示结果 else Token无效/过期 M-->>F: 返回401 Unauthorized F->>F: 响应拦截器捕获401 F->>U: 显示登录窗口 end ``` #### 8.2.2 组件架构 ``` ┌─────────────────────────────────────────────────────────────┐ │ 前端层 (Vue 3) │ ├─────────────────────────────────────────────────────────────┤ │ ┌─────────────┐ ┌──────────────┐ ┌──────────────────┐ │ │ │ LoginDialog │ │ HTTP拦截器 │ │ Token管理工具 │ │ │ │ 登录组件 │ │ 自动添加Token │ │ LocalStorage │ │ │ └─────────────┘ └──────────────┘ └──────────────────┘ │ └─────────────────────────────────────────────────────────────┘ ↕ HTTP (Authorization: Bearer) ┌─────────────────────────────────────────────────────────────┐ │ 后端层 (Go + Gin) │ ├─────────────────────────────────────────────────────────────┤ │ ┌──────────────────────────────────────────────────────┐ │ │ │ AuthMiddleware 认证中间件 │ │ │ │ • 检查AUTH_ENABLED配置 │ │ │ │ • 排除公开接口（/api/auth/login, /api/health） │ │ │ │ • 验证JWT Token有效性 │ │ │ │ • 提取用户信息到Context │ │ │ └──────────────────────────────────────────────────────┘ │ │ ↓ │ │ ┌─────────────┐ ┌─────────────┐ ┌──────────────────┐ │ │ │ 认证接口 │ │ JWT工具 │ │ 配置管理 │ │ │ │ /auth/login │ │ util/jwt.go │ │ config/config.go │ │ │ │ /auth/verify│ │ GenerateToken│ │ AuthEnabled │ │ │ │ /auth/logout│ │ ValidateToken│ │ AuthUsers │ │ │ └─────────────┘ └─────────────┘ └──────────────────┘ │ └─────────────────────────────────────────────────────────────┘ ``` ### 8.3 后端实现细节 #### 8.3.1 配置模块 (config/config.go) ```go type Config struct { // ... 现有配置 ... // 认证相关配置 AuthEnabled bool // 是否启用认证 AuthUsers map[string]string // 用户名:密码哈希映射 AuthTokenExpiry time.Duration // Token有效期 AuthJWTSecret string // JWT签名密钥 } // 从环境变量读取认证配置 func getAuthEnabled() bool { enabled := os.Getenv("AUTH_ENABLED") return enabled == "true" || enabled == "1" } func getAuthUsers() map[string]string { usersEnv := os.Getenv("AUTH_USERS") if usersEnv == "" { return nil } users := make(map[string]string) pairs := strings.Split(usersEnv, ",") for _, pair := range pairs { parts := strings.SplitN(pair, ":", 2) if len(parts) == 2 { username := strings.TrimSpace(parts[0]) password := strings.TrimSpace(parts[1]) // 实际使用时应该对密码进行哈希处理 users[username] = password } } return users } ``` #### 8.3.2 JWT工具模块 (util/jwt.go) ```go package util import ( "errors" "github.com/golang-jwt/jwt/v5" "time" ) // Claims JWT载荷结构 type Claims struct { Username string `json:"username"` jwt.RegisteredClaims } // GenerateToken 生成JWT token func GenerateToken(username string, secret string, expiry time.Duration) (string, error) { expirationTime := time.Now().Add(expiry) claims := &Claims{ Username: username, RegisteredClaims: jwt.RegisteredClaims{ ExpiresAt: jwt.NewNumericDate(expirationTime), IssuedAt: jwt.NewNumericDate(time.Now()), Issuer: "pansou", }, } token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims) return token.SignedString([]byte(secret)) } // ValidateToken 验证JWT token func ValidateToken(tokenString string, secret string) (*Claims, error) { claims := &Claims{} token, err := jwt.ParseWithClaims(tokenString, claims, func(token *jwt.Token) (interface{}, error) { return []byte(secret), nil }) if err != nil { return nil, err } if !token.Valid { return nil, errors.New("invalid token") } return claims, nil } ``` #### 8.3.3 认证中间件 (api/middleware.go) ```go // AuthMiddleware JWT认证中间件 func AuthMiddleware() gin.HandlerFunc { return func(c *gin.Context) { // 如果未启用认证，直接放行 if !config.AppConfig.AuthEnabled { c.Next() return } // 定义公开接口（不需要认证） publicPaths := []string{ "/api/auth/login", "/api/auth/verify", "/api/auth/logout", "/api/health", // 可选：健康检查是否需要认证 } // 检查当前路径是否是公开接口 path := c.Request.URL.Path for _, p := range publicPaths { if strings.HasPrefix(path, p) { c.Next() return } } // 获取Authorization头 authHeader := c.GetHeader("Authorization") if authHeader == "" { c.JSON(401, gin.H{ "error": "未授权：缺少认证令牌", "code": "AUTH_TOKEN_MISSING", }) c.Abort() return } // 解析Bearer token const bearerPrefix = "Bearer " if !strings.HasPrefix(authHeader, bearerPrefix) { c.JSON(401, gin.H{ "error": "未授权：令牌格式错误", "code": "AUTH_TOKEN_INVALID_FORMAT", }) c.Abort() return } tokenString := strings.TrimPrefix(authHeader, bearerPrefix) // 验证token claims, err := util.ValidateToken(tokenString, config.AppConfig.AuthJWTSecret) if err != nil { c.JSON(401, gin.H{ "error": "未授权：令牌无效或已过期", "code": "AUTH_TOKEN_INVALID", }) c.Abort() return } // 将用户信息存入上下文，供后续处理使用 c.Set("username", claims.Username) c.Next() } } ``` #### 8.3.4 认证接口 (api/auth_handler.go) ```go package api import ( "github.com/gin-gonic/gin" "pansou/config" "pansou/util" "time" ) // LoginRequest 登录请求结构 type LoginRequest struct { Username string `json:"username" binding:"required"` Password string `json:"password" binding:"required"` } // LoginResponse 登录响应结构 type LoginResponse struct { Token string `json:"token"` ExpiresAt int64 `json:"expires_at"` Username string `json:"username"` } // LoginHandler 处理用户登录 func LoginHandler(c *gin.Context) { var req LoginRequest if err := c.ShouldBindJSON(&req); err != nil { c.JSON(400, gin.H{"error": "参数错误"}) return } // 验证用户名和密码 if config.AppConfig.AuthUsers == nil { c.JSON(500, gin.H{"error": "认证系统未正确配置"}) return } storedPassword, exists := config.AppConfig.AuthUsers[req.Username] if !exists || storedPassword != req.Password { c.JSON(401, gin.H{"error": "用户名或密码错误"}) return } // 生成JWT token token, err := util.GenerateToken( req.Username, config.AppConfig.AuthJWTSecret, config.AppConfig.AuthTokenExpiry, ) if err != nil { c.JSON(500, gin.H{"error": "生成令牌失败"}) return } // 返回token和过期时间 expiresAt := time.Now().Add(config.AppConfig.AuthTokenExpiry).Unix() c.JSON(200, LoginResponse{ Token: token, ExpiresAt: expiresAt, Username: req.Username, }) } // VerifyHandler 验证token有效性 func VerifyHandler(c *gin.Context) { // 如果能到达这里，说明中间件已经验证通过 username, exists := c.Get("username") if !exists { c.JSON(401, gin.H{"error": "未授权"}) return } c.JSON(200, gin.H{ "valid": true, "username": username, }) } // LogoutHandler 退出登录（客户端删除token即可） func LogoutHandler(c *gin.Context) { c.JSON(200, gin.H{"message": "退出成功"}) } ``` ### 8.4 前端实现细节 #### 8.4.1 API模块扩展 (src/api/index.ts) ```typescript // 登录接口 export interface LoginParams { username: string; password: string; } export interface LoginResponse { token: string; expires_at: number; username: string; } export const login = async (params: LoginParams): Promise
AI小红书虚拟电商全链路实战课：从选品到变现的AI爆款打法
提取要素: - 标题: a 的文本内容或 title 属性 - 详情页链接: a 的 href 属性 ``` #### 分类标签 (.entry-cat-dot) ```html 提取要素: - 分类: 所有 a 标签的文本内容 ``` #### 描述区域 (.entry-desc) ```html
AI小红书虚拟电商全链路实战课程概览 《AI小红书虚拟电商5.0实战课》是一门聚焦AI与小红书生态融合的系统课程，围绕AI赋能选品、创作、运营与变现四大环节展开...
提取要素:
- 描述: div 的文本内容
```
#### 元数据栏 (.entry-meta)
```html
提取要素:
- 发布时间: time 标签的 datetime 属性或文本内容
```
## 详情页面结构
### 1. 详情页URL模式
```
https://www.ahhhhfs.com/{文章ID}/
示例:
https://www.ahhhhfs.com/76567/
```
### 2. 下载链接位置
下载链接在文章正文内容中 `.post-content` 里面，通常在文章末尾部分。
#### 下载链接格式示例
```html
学习地址： 夸克
或者下载地址： 百度网盘 提取码: xxxx
或者多个网盘链接：
阿里云盘：链接
夸克网盘：链接
百度网盘：链接 提取码: xxxx
` 标签分隔的下一行 - 括号内: `(提取码: xxxx)` 常见关键词： - 提取码 - 密码 - pwd - code - 取码 ### 3. 链接提取策略 1. 先从搜索结果页获取文章列表 2. 访问每篇文章的详情页 3. 在详情页的 `.post-content` 中查找包含网盘域名的链接 4. 提取链接和相应的提取码 5. 如果文章没有网盘链接，则跳过 ### 4. 时间格式处理 - 相对时间: "1 周前"、"2 天前" 需要转换为具体日期 - 绝对时间: "2025-10-18" 可以直接使用 - datetime 属性: "2025-10-18T13:43:10+08:00" 标准ISO格式 ### 5. 去重标识 - 使用文章ID作为唯一标识: 从详情页URL中提取 `/76567/` ## 注意事项 1. **搜索结果可能为空**: 如果关键词没有匹配结果，页面会显示"没有找到相关内容" 2. **分页**: 搜索结果可能有多页，但通常只抓取第一页即可 3. **网盘链接位置不固定**: 链接可能在文章开头、中间或结尾，需要遍历整个 `.post-content` 4. **广告干扰**: 页面包含广告，需要准确定位到实际内容区域 5. **需要访问详情页**: 搜索结果页不包含下载链接，必须访问详情页才能获取 6. **请求频率**: 需要访问详情页，建议控制请求频率避免被封 ## 示例数据流 ``` 1. 搜索请求: https://www.ahhhhfs.com/search/小红书 ↓ 2. 解析搜索结果页，提取文章列表 - 标题: "AI小红书虚拟电商全链路实战课：从选品到变现的AI爆款打法" - 详情页URL: https://www.ahhhhfs.com/76567/ - 分类: ["短视频", "资源"] - 发布时间: 2025-10-18 ↓ 3. 访问详情页: https://www.ahhhhfs.com/76567/ ↓ 4. 解析详情页 .post-content，提取网盘链接 - 夸克网盘: https://pan.quark.cn/s/c16a5ae18ea0 - 提取码: (如果有) ↓ 5. 构建最终结果 - UniqueID: ahhhhfs-76567 - Title: "AI小红书虚拟电商全链路实战课：从选品到变现的AI爆款打法" - Content: 文章描述 - Links: [{Type: "quark", URL: "...", Password: ""}] - Tags: ["短视频", "资源"] - Datetime: 2025-10-18T13:43:10+08:00 ``` ================================================ FILE: plugin/aikanzy/aikanzy.go ================================================ package aikanzy import ( "context" "fmt" "net/http" "net/url" "pansou/model" "pansou/plugin" "regexp" "strings" "sync" "time" "github.com/PuerkitoBio/goquery" ) // 预编译的正则表达式 var ( // 夸克网盘链接 quarkLinkRegex = regexp.MustCompile(`https?://pan\.quark\.cn/s/[0-9a-zA-Z]+`) // UC网盘链接 ucLinkRegex = regexp.MustCompile(`https?://drive\.uc\.cn/s/[0-9a-zA-Z]+(\?[^"'\s]*)?`) // 百度网盘链接 baiduLinkRegex = regexp.MustCompile(`https?://pan\.baidu\.com/s/[0-9a-zA-Z_-]+`) // 迅雷网盘链接 xunleiLinkRegex = regexp.MustCompile(`https?://pan\.xunlei\.com/s/[0-9a-zA-Z_-]+`) // 从URL中提取文章ID articleIDRegex = regexp.MustCompile(`/([a-z]+)/(\d+)\.html`) // 提取阅读数 viewCountRegex = regexp.MustCompile(`(\d+)\s*阅读`) ) // 常量定义 const ( // 插件名称 pluginName = "aikanzy" // 搜索URL模板 searchURLTemplate = "https://www.aikanzy.com/search?word=%s&molds=article" // 默认优先级 defaultPriority = 3 // 默认超时时间（秒） defaultTimeout = 15 // 详情页超时时间（秒） detailTimeout = 8 // 最大重试次数 maxRetries = 3 // 详情页并发数 detailConcurrency = 15 // 指数退避基数（毫秒） backoffBase = 200 ) // AikanzyAsyncPlugin 是AikanZY网站的异步搜索插件实现 type AikanzyAsyncPlugin struct { *plugin.BaseAsyncPlugin optimizedClient *http.Client } // 确保AikanzyAsyncPlugin实现了AsyncSearchPlugin接口 var _ plugin.AsyncSearchPlugin = (*AikanzyAsyncPlugin)(nil) // 在包初始化时注册插件 func init() { plugin.RegisterGlobalPlugin(NewAikanzyAsyncPlugin()) } // createOptimizedHTTPClient 创建优化的HTTP客户端 func createOptimizedHTTPClient() *http.Client { transport := &http.Transport{ MaxIdleConns: 100, MaxIdleConnsPerHost: 20, IdleConnTimeout: 90 * time.Second, DisableKeepAlives: false, } return &http.Client{ Transport: transport, Timeout: defaultTimeout * time.Second, } } // NewAikanzyAsyncPlugin 创建一个新的AikanZY异步插件实例 func NewAikanzyAsyncPlugin() *AikanzyAsyncPlugin { return &AikanzyAsyncPlugin{ BaseAsyncPlugin: plugin.NewBaseAsyncPlugin("aikanzy", defaultPriority), optimizedClient: createOptimizedHTTPClient(), } } // Name 返回插件名称 func (p *AikanzyAsyncPlugin) Name() string { return pluginName } // Priority 返回插件优先级 func (p *AikanzyAsyncPlugin) Priority() int { return defaultPriority } // Search 执行搜索并返回结果（兼容性方法） func (p *AikanzyAsyncPlugin) Search(keyword string, ext map[string]interface{}) ([]model.SearchResult, error) { result, err := p.SearchWithResult(keyword, ext) if err != nil { return nil, err } return result.Results, nil } // SearchWithResult 执行搜索并返回包含IsFinal标记的结果 func (p *AikanzyAsyncPlugin) SearchWithResult(keyword string, ext map[string]interface{}) (model.PluginSearchResult, error) { return p.AsyncSearchWithResult(keyword, p.doSearch, p.MainCacheKey, ext) } // doSearch 执行具体的搜索逻辑 func (p *AikanzyAsyncPlugin) doSearch(client *http.Client, keyword string, ext map[string]interface{}) ([]model.SearchResult, error) { // 使用优化的客户端 if p.optimizedClient != nil { client = p.optimizedClient } // 对关键词进行URL编码 encodedKeyword := url.QueryEscape(keyword) // 构建搜索URL searchURL := fmt.Sprintf(searchURLTemplate, encodedKeyword) // 创建一个带有超时的上下文 ctx, cancel := context.WithTimeout(context.Background(), defaultTimeout*time.Second) defer cancel() // 创建请求 req, err := http.NewRequestWithContext(ctx, "GET", searchURL, nil) if err != nil { return nil, fmt.Errorf("[%s] 创建请求失败: %w", p.Name(), err) } // 设置完整的请求头（避免反爬虫） req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36") req.Header.Set("Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8") req.Header.Set("Accept-Language", "zh-CN,zh;q=0.9,en;q=0.8") req.Header.Set("Connection", "keep-alive") req.Header.Set("Referer", "https://www.aikanzy.com/") req.Header.Set("Upgrade-Insecure-Requests", "1") req.Header.Set("Cache-Control", "max-age=0") // 使用带重试的请求方法发送HTTP请求 resp, err := p.doRequestWithRetry(req, client) if err != nil { return nil, fmt.Errorf("[%s] 请求搜索页面失败: %w", p.Name(), err) } defer resp.Body.Close() // 检查状态码 if resp.StatusCode != http.StatusOK { return nil, fmt.Errorf("[%s] 请求搜索页面失败，状态码: %d", p.Name(), resp.StatusCode) } // 使用goquery解析HTML doc, err := goquery.NewDocumentFromReader(resp.Body) if err != nil { return nil, fmt.Errorf("[%s] 解析HTML失败: %w", p.Name(), err) } // 解析搜索结果列表 articleItems := p.parseArticleList(doc) if len(articleItems) == 0 { return []model.SearchResult{}, nil } // 并发抓取详情页获取网盘链接 results := p.fetchDetailsWithLinks(articleItems, client, keyword) // 使用过滤功能过滤结果 filteredResults := plugin.FilterResultsByKeyword(results, keyword) return filteredResults, nil } // ArticleItem 文章基本信息 type ArticleItem struct { ID string Title string DetailURL string Category string PublishDate string ViewCount int Summary string ImageURL string } // parseArticleList 解析文章列表 func (p *AikanzyAsyncPlugin) parseArticleList(doc *goquery.Document) []ArticleItem { var items []ArticleItem // 查找所有文章项 doc.Find("article.post-list.contt.blockimg").Each(func(i int, s *goquery.Selection) { // 提取详情页链接 detailLink := s.Find("a[href]").First() detailURL, exists := detailLink.Attr("href") if !exists || detailURL == "" { return } // 提取文章ID articleID := p.extractArticleID(detailURL) if articleID == "" { return } // 提取标题 title := strings.TrimSpace(s.Find("header.entry-header span.entry-title a").Text()) // 移除标题中的HTML标签（如） title = p.cleanHTMLTags(title) if title == "" { return } // 提取分类 category := strings.TrimSpace(s.Find("div.entry-meta > a").First().Text()) // 提取发布日期 publishDate := strings.TrimSpace(s.Find("time").First().Text()) // 提取阅读数 metaText := s.Find("div.entry-meta").Text() viewCount := p.extractViewCount(metaText) // 提取摘要 summary := strings.TrimSpace(s.Find("div.entry-summary.ss p").Text()) summary = p.cleanHTMLTags(summary) // 提取缩略图 imageURL, _ := s.Find("img.block-fea").Attr("data-src") items = append(items, ArticleItem{ ID: articleID, Title: title, DetailURL: detailURL, Category: category, PublishDate: publishDate, ViewCount: viewCount, Summary: summary, ImageURL: imageURL, }) }) return items } // fetchDetailsWithLinks 并发抓取详情页获取网盘链接 func (p *AikanzyAsyncPlugin) fetchDetailsWithLinks(items []ArticleItem, client *http.Client, keyword string) []model.SearchResult { // 创建结果通道和等待组 resultChan := make(chan model.SearchResult, len(items)) var wg sync.WaitGroup // 创建信号量控制并发数 semaphore := make(chan struct{}, detailConcurrency) // 并发处理每个文章项 for _, item := range items { wg.Add(1) go func(item ArticleItem) { defer wg.Done() // 获取信号量 semaphore <- struct{}{} defer func() { <-semaphore }() // 抓取详情页 links := p.fetchDetailPageLinks(item.DetailURL, client) // 只有包含链接的结果才添加 if len(links) > 0 { // 解析发布时间 publishTime := p.parsePublishTime(item.PublishDate) // 组装内容 var contentParts []string if item.Summary != "" { contentParts = append(contentParts, item.Summary) } if item.Category != "" { contentParts = append(contentParts, item.Category) } if item.PublishDate != "" { contentParts = append(contentParts, item.PublishDate) } if item.ViewCount > 0 { contentParts = append(contentParts, fmt.Sprintf("%d阅读", item.ViewCount)) } content := strings.Join(contentParts, " | ") // 组装标签 var tags []string if item.Category != "" { tags = append(tags, item.Category) } result := model.SearchResult{ UniqueID: fmt.Sprintf("aikanzy-%s", item.ID), Title: item.Title, Content: content, Links: links, Tags: tags, Channel: "", // 插件搜索结果Channel为空 Datetime: publishTime, } resultChan <- result } }(item) } // 等待所有goroutine完成 go func() { wg.Wait() close(resultChan) }() // 收集所有结果 var results []model.SearchResult for result := range resultChan { results = append(results, result) } return results } // fetchDetailPageLinks 抓取详情页的网盘链接 func (p *AikanzyAsyncPlugin) fetchDetailPageLinks(detailURL string, client *http.Client) []model.Link { // 创建带超时的上下文 ctx, cancel := context.WithTimeout(context.Background(), detailTimeout*time.Second) defer cancel() // 创建请求 req, err := http.NewRequestWithContext(ctx, "GET", detailURL, nil) if err != nil { return nil } // 设置请求头 req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36") req.Header.Set("Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8") req.Header.Set("Accept-Language", "zh-CN,zh;q=0.9,en;q=0.8") req.Header.Set("Connection", "keep-alive") req.Header.Set("Referer", "https://www.aikanzy.com/") req.Header.Set("Upgrade-Insecure-Requests", "1") // 发送请求（带重试） resp, err := p.doRequestWithRetry(req, client) if err != nil { return nil } defer resp.Body.Close() // 检查状态码 if resp.StatusCode != http.StatusOK { return nil } // 解析HTML doc, err := goquery.NewDocumentFromReader(resp.Body) if err != nil { return nil } // 提取网盘链接 return p.extractNetDiskLinks(doc) } // extractNetDiskLinks 从详情页提取网盘链接 func (p *AikanzyAsyncPlugin) extractNetDiskLinks(doc *goquery.Document) []model.Link { var links []model.Link foundURLs := make(map[string]bool) // 用于去重 // 方法1: 从标签的href属性提取 doc.Find("a[href*='pan.quark.cn'], a[href*='drive.uc.cn'], a[href*='pan.baidu.com'], a[href*='pan.xunlei.com']").Each(func(i int, s *goquery.Selection) { href, exists := s.Attr("href") if !exists || href == "" { return } // 去重 if foundURLs[href] { return } foundURLs[href] = true // 确定链接类型 linkType := p.determineLinkType(href) if linkType == "" { return } links = append(links, model.Link{ Type: linkType, URL: href, Password: p.extractPassword(href), }) }) // 方法2: 从页面HTML文本中提取（正则表达式） if len(links) == 0 { html, _ := doc.Html() // 提取夸克网盘链接 quarkLinks := quarkLinkRegex.FindAllString(html, -1) for _, link := range quarkLinks { if !foundURLs[link] { foundURLs[link] = true links = append(links, model.Link{ Type: "quark", URL: link, Password: p.extractPassword(link), }) } } // 提取UC网盘链接 ucLinks := ucLinkRegex.FindAllString(html, -1) for _, link := range ucLinks { if !foundURLs[link] { foundURLs[link] = true links = append(links, model.Link{ Type: "uc", URL: link, Password: p.extractPassword(link), }) } } // 提取百度网盘链接 baiduLinks := baiduLinkRegex.FindAllString(html, -1) for _, link := range baiduLinks { if !foundURLs[link] { foundURLs[link] = true links = append(links, model.Link{ Type: "baidu", URL: link, Password: p.extractPassword(link), }) } } // 提取迅雷网盘链接 xunleiLinks := xunleiLinkRegex.FindAllString(html, -1) for _, link := range xunleiLinks { if !foundURLs[link] { foundURLs[link] = true links = append(links, model.Link{ Type: "xunlei", URL: link, Password: p.extractPassword(link), }) } } } return links } // determineLinkType 根据URL确定链接类型 func (p *AikanzyAsyncPlugin) determineLinkType(urlStr string) string { lowerURL := strings.ToLower(urlStr) switch { case strings.Contains(lowerURL, "pan.quark.cn"): return "quark" case strings.Contains(lowerURL, "drive.uc.cn"): return "uc" case strings.Contains(lowerURL, "pan.baidu.com"): return "baidu" case strings.Contains(lowerURL, "pan.xunlei.com"): return "xunlei" default: return "" } } // extractArticleID 从URL中提取文章ID func (p *AikanzyAsyncPlugin) extractArticleID(urlStr string) string { matches := articleIDRegex.FindStringSubmatch(urlStr) if len(matches) >= 3 { return matches[2] // 返回数字ID } return "" } // extractViewCount 提取阅读数 func (p *AikanzyAsyncPlugin) extractViewCount(text string) int { matches := viewCountRegex.FindStringSubmatch(text) if len(matches) >= 2 { var count int fmt.Sscanf(matches[1], "%d", &count) return count } return 0 } // cleanHTMLTags 清除HTML标签 func (p *AikanzyAsyncPlugin) cleanHTMLTags(text string) string { // 移除标签 text = regexp.MustCompile(`
变形金刚 超能勇士崛起
视频下载 (夸克网盘)： https://pan.quark.cn/s/a372a91a0296
HTML格式的完整帖子内容...
", "post_number": 1, "topic_id": 1067663, "link_counts": [ { "url": "https://pan.quark.cn/s/d6b8b0908959", "internal": false, "reflection": false, "clicks": 29 }, { "url": "https://pan.baidu.com/s/1KJylsrBbKbMhi9e-i9YMVA?pwd=tn44", "internal": false, "reflection": false, "clicks": 16 } ] } ] }, "id": 1067663, "title": "遮天 第132集＆紫川2更15集 【4K高码】", "fancy_title": "遮天 第132集＆紫川2更15集 【4K高码】", "tags": ["夸克网盘", "影视", "百度网盘", "动漫"], "category_id": 94 } ``` ### 关键字段说明 #### post_stream.posts[0]（主帖内容） | 字段名 | 类型 | 说明 | |--------|------|------| | `cooked` | string | **HTML格式的完整帖子内容** | | `link_counts` | array | **所有外部链接列表（含网盘链接）** | #### link_counts 数组 这是最可靠的链接提取来源，包含了帖子中所有外部链接： ```json { "url": "https://pan.quark.cn/s/d6b8b0908959", "internal": false, "reflection": false, "clicks": 29 } ``` | 字段名 | 类型 | 说明 | |--------|------|------| | `url` | string | **完整的链接URL** | | `internal` | bool | 是否为内部链接（false表示外部链接） | | `clicks` | int | 点击次数 | ### 数据提取策略 **推荐方式**：优先使用 `link_counts` 数组 1. ✅ **最可靠**：由服务器解析，不会遗漏或截断 2. ✅ **最完整**：包含所有外部链接 3. ✅ **易解析**：结构化数据，无需正则表达式 ```go // 从 link_counts 提取网盘链接 for _, linkCount := range post.LinkCounts { // 跳过内部链接 if linkCount.Internal { continue } // 判断是否为网盘链接 if isNetDiskURL(linkCount.URL) { link := parseNetDiskLink(linkCount.URL) links = append(links, link) } } ``` **备用方式**：从 `cooked` HTML 中提取 当 `link_counts` 为空或不完整时，可以从 HTML 中提取： ```go // 使用 goquery 解析 HTML doc, _ := goquery.NewDocumentFromReader(strings.NewReader(post.Cooked)) // 提取所有 标签 doc.Find("a").Each(func(i int, s *goquery.Selection) { href, exists := s.Attr("href") if exists && isNetDiskURL(href) { link := parseNetDiskLink(href) links = append(links, link) } }) ``` ## 实现策略 ### 两步法获取完整数据 1. **第一步：搜索API** - 获取帖子列表和基本信息 - 从 `blurb` 快速提取部分链接 - 获取 `topic_id` 用于详情请求 2. **第二步：详情API**（按需） - 当 `blurb` 中链接不完整时 - 或需要获取完整帖子内容时 - 使用 `link_counts` 获取所有链接 ### 性能优化建议 - ✅ **批量获取**：使用协程并发请求多个详情页 - ✅ **智能跳过**：如果搜索结果已有完整链接，跳过详情请求 - ✅ **缓存结果**：相同 `topic_id` 的详情可缓存 - ⚠️ **速率限制**：避免请求过快被限流 ## 示例 ### 1. 搜索API 示例 #### 请求 ``` GET https://linux.do/search.json?q=%E9%81%AE%E5%A4%A9%20%23resource%3Acloud-asset%20in%3Atitle&page=1 ``` #### 响应（简化） ```json { "posts": [ { "id": 9619992, "username": "lxwh", "created_at": "2025-10-21T10:29:05.613Z", "blurb": "夸克网盘： https://pan.quark.cn/s/99758a147076", "topic_id": 1067663 } ], "topics": [ { "id": 1067663, "title": "遮天 第132集＆紫川2更15集 【4K高码】", "tags": ["夸克网盘", "影视", "动漫"] } ] } ``` ### 2. 详情API 示例 #### 请求 ``` GET https://linux.do/t/1067663.json?track_visit=true&forceLoad=true ``` #### 响应（简化） ```json { "post_stream": { "posts": [ { "id": 9619992, "link_counts": [ { "url": "https://pan.quark.cn/s/d6b8b0908959", "internal": false, "clicks": 29 }, { "url": "https://pan.baidu.com/s/1KJylsrBbKbMhi9e-i9YMVA?pwd=tn44", "internal": false, "clicks": 16 } ] } ] }, "title": "遮天 第132集＆紫川2更15集 【4K高码】" } ``` ================================================ FILE: plugin/djgou/djgou.go ================================================ package djgou import ( "context" "fmt" "net/http" "net/url" "pansou/model" "pansou/plugin" "regexp" "strings" "sync" "time" "github.com/PuerkitoBio/goquery" ) // 预编译的正则表达式 var ( // 夸克网盘链接正则表达式（网站只有夸克网盘） // 注意：夸克链接可能包含字母、数字、下划线、连字符等字符 quarkLinkRegex = regexp.MustCompile(`https?://pan\.quark\.cn/s/[0-9a-zA-Z_\-]+`) // 提取码正则表达式 pwdRegex = regexp.MustCompile(`提取码[:：]\s*([a-zA-Z0-9]{4})`) // 缓存相关 detailCache = sync.Map{} // 缓存详情页解析结果 lastCleanupTime = time.Now() cacheTTL = 1 * time.Hour ) const ( // 超时时间 DefaultTimeout = 8 * time.Second DetailTimeout = 6 * time.Second // 并发数（精简后的代码使用较低的并发即可） MaxConcurrency = 15 // HTTP连接池配置 MaxIdleConns = 50 MaxIdleConnsPerHost = 20 MaxConnsPerHost = 30 IdleConnTimeout = 90 * time.Second // 网站URL SiteURL = "https://duanjugou.top" ) // 在init函数中注册插件 func init() { plugin.RegisterGlobalPlugin(NewDjgouPlugin()) // 启动缓存清理goroutine go startCacheCleaner() } // startCacheCleaner 启动一个定期清理缓存的goroutine func startCacheCleaner() { ticker := time.NewTicker(30 * time.Minute) defer ticker.Stop() for range ticker.C { // 清空所有缓存 detailCache = sync.Map{} lastCleanupTime = time.Now() } } // DjgouPlugin 短剧狗插件 type DjgouPlugin struct { *plugin.BaseAsyncPlugin optimizedClient *http.Client } // createOptimizedHTTPClient 创建优化的HTTP客户端 func createOptimizedHTTPClient() *http.Client { transport := &http.Transport{ MaxIdleConns: MaxIdleConns, MaxIdleConnsPerHost: MaxIdleConnsPerHost, MaxConnsPerHost: MaxConnsPerHost, IdleConnTimeout: IdleConnTimeout, DisableKeepAlives: false, } return &http.Client{Transport: transport, Timeout: DefaultTimeout} } // NewDjgouPlugin 创建新的短剧狗插件 func NewDjgouPlugin() *DjgouPlugin { return &DjgouPlugin{ BaseAsyncPlugin: plugin.NewBaseAsyncPlugin("djgou", 2), // 优先级2：质量良好的数据源 optimizedClient: createOptimizedHTTPClient(), } } // Search 执行搜索并返回结果（兼容性方法） func (p *DjgouPlugin) Search(keyword string, ext map[string]interface{}) ([]model.SearchResult, error) { result, err := p.SearchWithResult(keyword, ext) if err != nil { return nil, err } return result.Results, nil } // SearchWithResult 执行搜索并返回包含IsFinal标记的结果 func (p *DjgouPlugin) SearchWithResult(keyword string, ext map[string]interface{}) (model.PluginSearchResult, error) { return p.AsyncSearchWithResult(keyword, p.searchImpl, p.MainCacheKey, ext) } // searchImpl 实现具体的搜索逻辑 func (p *DjgouPlugin) searchImpl(client *http.Client, keyword string, ext map[string]interface{}) ([]model.SearchResult, error) { // 1. 构建搜索URL searchURL := fmt.Sprintf("%s/search.php?q=%s&page=1", SiteURL, url.QueryEscape(keyword)) // 2. 创建带超时的上下文 ctx, cancel := context.WithTimeout(context.Background(), DefaultTimeout) defer cancel() // 3. 创建请求 req, err := http.NewRequestWithContext(ctx, "GET", searchURL, nil) if err != nil { return nil, fmt.Errorf("[%s] 创建请求失败: %w", p.Name(), err) } // 4. 设置完整的请求头（避免反爬虫） req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36") req.Header.Set("Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8") req.Header.Set("Accept-Language", "zh-CN,zh;q=0.9,en;q=0.8") req.Header.Set("Connection", "keep-alive") req.Header.Set("Upgrade-Insecure-Requests", "1") req.Header.Set("Cache-Control", "max-age=0") req.Header.Set("Referer", SiteURL) // 5. 发送请求（带重试机制） resp, err := p.doRequestWithRetry(req, client) if err != nil { return nil, fmt.Errorf("[%s] 搜索请求失败: %w", p.Name(), err) } defer resp.Body.Close() if resp.StatusCode != 200 { return nil, fmt.Errorf("[%s] 搜索请求返回状态码: %d", p.Name(), resp.StatusCode) } // 6. 解析搜索结果页面 doc, err := goquery.NewDocumentFromReader(resp.Body) if err != nil { return nil, fmt.Errorf("[%s] 解析搜索页面失败: %w", p.Name(), err) } // 7. 提取搜索结果 var results []model.SearchResult // 查找主列表容器 mainListSection := doc.Find("div.erx-list-box") if mainListSection.Length() == 0 { return nil, fmt.Errorf("[%s] 未找到erx-list-box容器", p.Name()) } // 查找列表项 items := mainListSection.Find("ul.erx-list li.item") if items.Length() == 0 { return []model.SearchResult{}, nil // 没有搜索结果 } // 8. 解析每个搜索结果项 items.Each(func(i int, s *goquery.Selection) { result := p.parseSearchItem(s, keyword) if result.UniqueID != "" { results = append(results, result) } }) // 9. 异步获取详情页信息 enhancedResults := p.enhanceWithDetails(client, results) // 10. 关键词过滤 return plugin.FilterResultsByKeyword(enhancedResults, keyword), nil } // parseSearchItem 解析单个搜索结果项 func (p *DjgouPlugin) parseSearchItem(s *goquery.Selection, keyword string) model.SearchResult { result := model.SearchResult{} // 提取标题区域 aDiv := s.Find("div.a") if aDiv.Length() == 0 { return result } // 提取链接和标题 linkElem := aDiv.Find("a.main") if linkElem.Length() == 0 { return result } title := strings.TrimSpace(linkElem.Text()) link, exists := linkElem.Attr("href") if !exists || link == "" { return result } // 处理相对路径 if !strings.HasPrefix(link, "http") { if strings.HasPrefix(link, "/") { link = SiteURL + link } else { link = SiteURL + "/" + link } } // 提取时间 timeText := "" iDiv := s.Find("div.i") if iDiv.Length() > 0 { timeSpan := iDiv.Find("span.time") if timeSpan.Length() > 0 { timeText = strings.TrimSpace(timeSpan.Text()) } } // 生成唯一ID（使用链接的路径部分） itemID := strings.TrimPrefix(link, SiteURL) itemID = strings.Trim(itemID, "/") result.UniqueID = fmt.Sprintf("%s-%s", p.Name(), url.QueryEscape(itemID)) result.Title = title result.Datetime = p.parseTime(timeText) result.Tags = []string{"短剧"} result.Channel = "" // 插件搜索结果必须为空字符串 // 将详情页链接存储在Content中，后续获取详情 result.Content = link return result } // parseTime 解析时间字符串 func (p *DjgouPlugin) parseTime(timeStr string) time.Time { if timeStr == "" { return time.Now() } // 尝试多种时间格式 formats := []string{ "2006-01-02 15:04:05", "2006-01-02 15:04", "2006-01-02", "2006/01/02 15:04:05", "2006/01/02 15:04", "2006/01/02", } for _, format := range formats { if t, err := time.Parse(format, timeStr); err == nil { return t } } return time.Now() } // enhanceWithDetails 异步获取详情页信息 func (p *DjgouPlugin) enhanceWithDetails(client *http.Client, results []model.SearchResult) []model.SearchResult { var wg sync.WaitGroup var mu sync.Mutex // 使用信号量控制并发数 semaphore := make(chan struct{}, MaxConcurrency) enhancedResults := make([]model.SearchResult, 0, len(results)) for _, result := range results { wg.Add(1) go func(r model.SearchResult) { defer wg.Done() // 获取信号量 semaphore <- struct{}{} defer func() { <-semaphore }() // 从缓存或详情页获取链接 links, content := p.getDetailInfo(client, r.Content) // 更新结果 r.Links = links r.Content = content // 只添加有链接的结果 if len(links) > 0 { mu.Lock() enhancedResults = append(enhancedResults, r) mu.Unlock() } }(result) } wg.Wait() return enhancedResults } // getDetailInfo 获取详情页信息（带缓存） func (p *DjgouPlugin) getDetailInfo(client *http.Client, detailURL string) ([]model.Link, string) { // 检查缓存 if cached, ok := detailCache.Load(detailURL); ok { cachedData := cached.(DetailCacheData) if time.Since(cachedData.Timestamp) < cacheTTL { return cachedData.Links, cachedData.Content } } // 获取详情页 links, content := p.fetchDetailPage(client, detailURL) // 存入缓存 if len(links) > 0 { detailCache.Store(detailURL, DetailCacheData{ Links: links, Content: content, Timestamp: time.Now(), }) } return links, content } // DetailCacheData 详情页缓存数据 type DetailCacheData struct { Links []model.Link Content string Timestamp time.Time } // fetchDetailPage 获取详情页信息 func (p *DjgouPlugin) fetchDetailPage(client *http.Client, detailURL string) ([]model.Link, string) { // 创建带超时的上下文 ctx, cancel := context.WithTimeout(context.Background(), DetailTimeout) defer cancel() // 创建请求 req, err := http.NewRequestWithContext(ctx, "GET", detailURL, nil) if err != nil { return nil, "" } // 设置请求头 req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36") req.Header.Set("Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8") req.Header.Set("Accept-Language", "zh-CN,zh;q=0.9,en;q=0.8") req.Header.Set("Referer", SiteURL) // 发送请求 resp, err := client.Do(req) if err != nil { return nil, "" } defer resp.Body.Close() if resp.StatusCode != 200 { return nil, "" } // 解析页面 doc, err := goquery.NewDocumentFromReader(resp.Body) if err != nil { return nil, "" } // 查找主内容区域（用于提取简介） mainContent := doc.Find("div.erx-wrap") if mainContent.Length() == 0 { return nil, "" } // 提取网盘链接（从整个页面HTML中提取，不仅仅是mainContent） links := p.extractLinksFromDoc(doc) // 提取简介（从mainContent提取） content := p.extractContent(mainContent) return links, content } // extractLinksFromDoc 从整个文档中提取夸克网盘链接（重要：从整个页面HTML中提取，不限于某个div） func (p *DjgouPlugin) extractLinksFromDoc(doc *goquery.Document) []model.Link { var links []model.Link linkMap := make(map[string]bool) // 去重 // 获取整个页面的HTML内容（这是关键！） htmlContent, _ := doc.Html() // 提取提取码 password := "" if match := pwdRegex.FindStringSubmatch(htmlContent); len(match) > 1 { password = match[1] } // 方法1：使用专用正则表达式提取夸克网盘链接 quarkLinks := quarkLinkRegex.FindAllString(htmlContent, -1) for _, quarkURL := range quarkLinks { // 去重 if !linkMap[quarkURL] { linkMap[quarkURL] = true links = append(links, model.Link{ Type: "quark", URL: quarkURL, Password: password, }) } } // 方法2：从所有标签中查找夸克链接（作为补充） doc.Find("a").Each(func(i int, s *goquery.Selection) { href, exists := s.Attr("href") if !exists || href == "" { return } // 检查是否是夸克网盘链接 if strings.Contains(href, "pan.quark.cn") { // 去重 if !linkMap[href] { linkMap[href] = true links = append(links, model.Link{ Type: "quark", URL: href, Password: password, }) } } }) return links } // extractContent 提取简介 func (p *DjgouPlugin) extractContent(mainContent *goquery.Selection) string { content := strings.TrimSpace(mainContent.Text()) // 清理空白字符 content = regexp.MustCompile(`\s+`).ReplaceAllString(content, " ") // 限制长度 if len(content) > 300 { content = content[:300] + "..." } return content } // doRequestWithRetry 带重试机制的HTTP请求 func (p *DjgouPlugin) doRequestWithRetry(req *http.Request, client *http.Client) (*http.Response, error) { maxRetries := 3 var lastErr error for i := 0; i < maxRetries; i++ { if i > 0 { // 指数退避重试 backoff := time.Duration(1<夸克[^<]*
\s*百度[^<]* 阿里[^<]* 天翼[^<]* 迅雷[^<]* {网盘名}")
hasLIInNoscript := strings.Contains(noscriptContent, "
