update:基础框架用法实现。极致神似drpy2用法

hjdhnx · hjdhnx · commit c94a43804a58 · 2024-11-27T04:52:41.000+08:00
diff --git a/index.js b/index.js
@@ -1,44 +1,63 @@
-import Fastify from 'fastify';  // 使用命名导入 Fastify
-import path from 'path';  // 使用 Node.js 的 path 模块来处理文件路径
-
-// 使用 pino-pretty 来格式化日志输出
-import pino from 'pino';
-import pinoPretty from 'pino-pretty';
-
-// 创建 pino-pretty 配置
-const prettyPrintOptions = {
-    colorize: true,  // 启用颜色输出
-    translateTime: 'SYS:standard',  // 显示标准时间
-    ignore: 'pid,hostname'  // 忽略 pid 和 hostname
-};
+import Fastify from 'fastify';
+import * as drpy from './libs/drpy.js';
+import path from 'path';
+import {fileURLToPath} from 'url';
 
-// 创建 Fastify 实例
-const fastify = Fastify({
-    logger: pino({
-        level: 'info',  // 设置日志级别
-        prettyPrint: false  // 禁用内置 prettyPrint
-    }).child({}, {stream: pinoPretty(prettyPrintOptions)})  // 使用 pino-pretty 进行日志格式化
-});
+const fastify = Fastify({logger: true});
 
-// 引入封装好的库
-import * as drpy from './libs/drpy.js';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+console.log('__dirname:', __dirname);
 
-// API 接口: 根据模块名加载相应的 js 文件，并调用 drpy 的方法
+// 动态加载模块并根据 query 执行不同逻辑
 fastify.get('/api/:module', async (request, reply) => {
-    const moduleName = request.params.module;  // 获取模块名，例如 '360'
-    const modulePath = new URL(`./js/${moduleName}.js`, import.meta.url).pathname;  // 获取模块路径
+    const moduleName = request.params.module;
+    const query = request.query; // 获取 query 参数
+    const modulePath = path.join(__dirname, 'js', `${moduleName}.js`);
 
     try {
-        // 动态加载 js 文件
-        const module = await import(modulePath);  // 使用动态导入加载模块
-        console.log(module)
-
-        // 由于 `360.js` 使用的是全局的 `rule` 变量，我们通过 `module.default` 获取
-        const result = await drpy.init(module.rule);  // 使用 `module.rule` 直接调用
-        // 返回结果
-        return reply.send(result);
+        // 根据 query 参数决定执行逻辑
+        if ('play' in query) {
+            // 处理播放逻辑
+            const result = await drpy.play(modulePath);
+            return reply.send(result);
+        }
+
+        if ('ac' in query && 't' in query) {
+            // 分类逻辑
+            const result = await drpy.cate(modulePath);
+            return reply.send(result);
+        }
+
+        if ('ac' in query && 'ids' in query) {
+            // 详情逻辑
+            const result = await drpy.detail(modulePath);
+            return reply.send(result);
+        }
+
+        if ('wd' in query) {
+            // 搜索逻辑
+            const result = await drpy.search(modulePath);
+            return reply.send(result);
+        }
+
+        if ('refresh' in query) {
+            // 强制刷新初始化逻辑
+            const refreshedObject = await drpy.init(modulePath, true);
+            return reply.send(refreshedObject);
+        }
+
+        // 默认逻辑，返回 home + homeVod 接口
+        const result_home = await drpy.home(modulePath);
+        const result_homeVod = await drpy.homeVod(modulePath);
+        const result = {
+            class: result_home,
+            list: result_homeVod
+        }
+        reply.send(result);
+
     } catch (error) {
-        reply.status(500).send({error: `Failed to load module ${moduleName}: ${error.message}`});
+        console.error('Error processing request:', error);
+        reply.status(500).send({error: `Failed to process request for module ${moduleName}: ${error.message}`});
     }
 });
 
diff --git a/js/360.js b/js/360.js
@@ -1,11 +1,46 @@
 // js/360.js
-export var rule = {
+
+var rule = {
     title: '标题1',
     description: '这是描述',
     category: '视频',
-    一级:async (req)=>{
+    class_parse: async () => {
+        console.log('执行了分类获取')
+        return [
+            {type_id: '1', type_name: '电影'},
+            {type_id: '2', type_name: '电视剧'},
+            {type_id: '3', type_name: '综艺'},
+            {type_id: '4', type_name: '动漫'},
+        ]
+    },
+    预处理: async () => {
+        console.log('执行了预处理')
+        rule.title = '360影视'
+    },
+    推荐: async () => {
+        sleepSync(2000);
+        console.log('进入了推荐')
+        // return '这是推荐:' + rule.title
+        return [
+            {vod_name: '测试电影1', vod_pic: '1.png', vod_remarks: '测试描述1', vod_id: 'http://www.1.com'},
+            {vod_name: '测试电影2', vod_pic: '2.png', vod_remarks: '测试描述2', vod_id: 'http://www.2.com'},
+        ]
+    },
+    一级: async () => {
+        // await sleep(200);
+        sleepSync(200);
         let html = await req('123');
-        // console.log(html);
-        return html
+        console.log('title:', rule.title);
+        console.log('html:' + html);
+        return html + '\n' + '这是一级:' + rule.title
+    },
+    二级: async () => {
+        return '这是二级:' + rule.title
+    },
+    搜索: async () => {
+        return '这是搜索:' + rule.title
+    },
+    lazy: async () => {
+        return '这是播放:' + rule.title
     },
 };
diff --git a/libs/drpy.js b/libs/drpy.js
@@ -1,63 +1,107 @@
-// drpy.js: 封装模块，包含处理逻辑
+import * as utils from '../utils/utils.js'; // 使用 import 引入工具类
+import {readFile} from 'fs/promises';
+import vm from 'vm'; // Node.js 的 vm 模块
 
-import * as utils from '../utils/utils.js';  // 使用 import 引入工具类
-const { req } = await import('../utils/req.js');
+const {req} = await import('../utils/req.js');
+const {sleep, sleepSync} = await import('../utils/utils.js');
+
+// 缓存已初始化的模块
+const moduleCache = new Map();
+
+/**
+ * 初始化模块：加载并执行模块文件，存储初始化后的 rule 对象
+ * 如果存在 `预处理` 属性且为函数，会在缓存前执行
+ * @param {string} filePath - 模块文件路径
+ * @param refresh 强制清除缓存
+ * @returns {Promise<object>} - 返回初始化后的模块对象
+ */
+export async function init(filePath, refresh) {
+    if (moduleCache.has(filePath) && !refresh) {
+        console.log(`Module ${filePath} already initialized, returning cached instance.`);
+        return moduleCache.get(filePath);
+    }
 
-export async function init(rule) {
-    // 假设我们传入的 moduleObject 是 js/360.js 中的 rule 对象
-    const moduleObject = utils.deepCopy(rule)
     try {
-        // 读取并修改传入的对象
-        if (moduleObject && moduleObject.title) {
-            moduleObject.title += ' (drpy)';  // 修改 title 属性
-        }
+        let t1 = utils.getNowTime();
+        // 读取 JS 文件的内容
+        const fileContent = await readFile(filePath, 'utf-8');
 
-        // 你可以根据需要修改其他属性
-        if (moduleObject && moduleObject.description) {
-            moduleObject.description += ' [Modified]';
-        }
-        const title = moduleObject.title
-        console.log(moduleObject)
-        const titleLength = utils.getTitleLength(title);  // 使用 utils.js 中的方法
+        // 创建一个沙箱上下文，注入需要的全局变量和函数
+        const sandbox = {
+            console,
+            req,
+            sleep,
+            sleepSync,
+            utils,
+            rule: {}, // 用于存放导出的 rule 对象
+        };
+
+        // 创建一个上下文
+        const context = vm.createContext(sandbox);
 
+        // 执行文件内容，将其放入沙箱中
+        const script = new vm.Script(fileContent);
+        script.runInContext(context);
 
-        Object.assign(moduleObject, {
-            message: `Module initialized with title: ${title}`,
-            titleLength: titleLength
-        })
+        // 访问沙箱中的 rule 对象
+        const moduleObject = utils.deepCopy(sandbox.rule);
 
-        console.log(typeof moduleObject.一级)
-        if( typeof moduleObject.一级 === 'function'){
-            let html = await moduleObject.一级(req)
-            console.log(html)
-            moduleObject.html = html
+        // 检查并执行 `预处理` 方法
+        if (typeof moduleObject.预处理 === 'function') {
+            console.log('Executing preprocessing...');
+            await moduleObject.预处理();
         }
 
-        // 返回修改后的对象
+        // 缓存初始化后的模块
+        moduleCache.set(filePath, moduleObject);
+
+        let t2 = utils.getNowTime();
+        moduleObject.cost = t2 - t1;
+
         return moduleObject;
     } catch (error) {
         console.error('Error in drpy.init:', error);
         throw new Error('Failed to initialize module');
     }
 }
 
-// 其他方法可以依照需求继续添加
-export async function home() {
-    return {message: 'Home method'};
+/**
+ * 调用模块的指定方法
+ * @param {string} filePath - 模块文件路径
+ * @param {string} method - 要调用的属性方法名称
+ * @returns {Promise<any>} - 方法调用的返回值
+ */
+async function invokeMethod(filePath, method) {
+    const moduleObject = await init(filePath); // 确保模块已初始化
+    if (moduleObject[method] && typeof moduleObject[method] === 'function') {
+        return await moduleObject[method](); // 调用对应的方法
+    } else {
+        throw new Error(`Method ${method} not found in module ${filePath}`);
+    }
+}
+
+// 各种接口调用方法
+
+export async function home(filePath) {
+    return await invokeMethod(filePath, 'class_parse');
+}
+
+export async function homeVod(filePath) {
+    return await invokeMethod(filePath, '推荐');
 }
 
-export async function cate() {
-    return {message: 'Cate method'};
+export async function cate(filePath) {
+    return await invokeMethod(filePath, '一级');
 }
 
-export async function detail() {
-    return {message: 'Detail method'};
+export async function detail(filePath) {
+    return await invokeMethod(filePath, '二级');
 }
 
-export async function play() {
-    return {message: 'Play method'};
+export async function search(filePath) {
+    return await invokeMethod(filePath, '搜索');
 }
 
-export async function search() {
-    return {message: 'Search method'};
+export async function play(filePath) {
+    return await invokeMethod(filePath, 'lazy');
 }
diff --git a/utils/utils.js b/utils/utils.js
@@ -7,4 +7,24 @@ export function getTitleLength(title) {
     return title.length;  // 返回标题长度
 }
 
+export function getNowTime() {
+    return (new Date()).getTime()
+}
+
+export async function sleep(ms) {
+    // 模拟异步请求
+    return new Promise((resolve) => {
+        setTimeout(() => {
+            resolve();
+        }, ms);
+    });
+}
+
+export function sleepSync(ms) {
+    const end = Date.now() + ms; // 获取当前时间并计算结束时间
+    while (Date.now() < end) {
+        // 阻塞式等待，直到时间到达
+    }
+}
+
 export const deepCopy = cloneDeep
diff --git a/对话1.txt b/对话1.txt
