mm_ip 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Admin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/index.js

@@ -0,0 +1,684 @@
+/**
+ * IP管理模块
+ * @file IP管理模块，支持白名单、黑名单管理，IP请求频率和次数记录
+ */
+require('mm_expand');
+
+/**
+ * IP管理类
+ * @class
+ */
+class Ip {
+    /**
+     * 创建IP管理实例
+     * @param {Object} config - 配置选项
+     */
+    constructor(config) {
+        this._config = Object.assign({
+            max_white: 1000,
+            max_black: 1000,
+            check_interval: 60000, // 1分钟
+            max_req_per_min: 100,
+            auto_black_enable: true, // 启用自动高频拉黑
+            auto_black_threshold: 50, // 自动拉黑阈值（每分钟请求数）
+            auto_black_duration: 3600000, // 自动拉黑持续时间（1小时）
+            violation_enable: true, // 启用违规记录
+            violation_max_count: 10, // 最大违规次数
+            violation_reset_time: 86400000, // 违规记录重置时间（24小时）
+            violation_auto_black: true // 违规次数超限自动拉黑
+        }, config || {});
+        
+        this._white = new Set();
+        this._black = new Set();
+        this._req_count = new Map();
+        this._req_time = new Map();
+        this._black_time = new Map(); // 记录拉黑时间
+        this._violation_count = new Map(); // 违规次数记录
+        this._violation_time = new Map(); // 违规时间记录
+        this._logger = $.log || console;
+    }
+}
+
+/**
+ * 设置日志器
+ * @param {Object} logger - 日志对象
+ */
+Ip.prototype.setup = function (logger) {
+    if (logger && typeof logger === 'object') {
+        this._logger = logger;
+    }
+};
+
+/**
+ * 日志记录
+ * @param {string} level - 日志级别（如：info, warn, error）
+ * @param {string} message - 日志消息
+ * @param {...*} args - 可选的日志参数
+ */
+Ip.prototype.logger = function (level, message, ...args) {
+    this._logger[level](`${this.constructor.name} ${message}`, ...args);
+};
+
+/**
+ * 添加IP到白名单
+ * @param {string} ip - IP地址
+ * @returns {boolean} 是否添加成功
+ * @throws {TypeError} 当IP非字符串时
+ */
+Ip.prototype.addWhite = function (ip) {
+    if (typeof ip !== 'string') throw new TypeError('ip must be string');
+
+    if (this.getAllWhite().length >= this._config.max_white) {
+        this.logger('warn', '白名单已满，无法添加IP:', ip);
+        return false;
+    }
+
+    this._white.add(ip);
+    this.logger('info', '添加白名单IP:', ip);
+    return true;
+};
+
+/**
+ * 添加IP到黑名单
+ * @param {string} ip - IP地址
+ * @returns {boolean} 是否添加成功
+ * @throws {TypeError} 当IP非字符串时
+ */
+Ip.prototype.addBlack = function (ip) {
+    if (typeof ip !== 'string') throw new TypeError('ip must be string');
+
+    if (this.getAllBlack().length >= this._config.max_black) {
+        this.logger('warn', '黑名单已满，无法添加IP:', ip);
+        return false;
+    }
+
+    this._black.add(ip);
+    this.logger('info', '添加黑名单IP:', ip);
+    return true;
+};
+
+/**
+ * 从白名单删除IP
+ * @param {string} ip - IP地址
+ * @returns {boolean} 是否删除成功
+ * @throws {TypeError} 当IP非字符串时
+ */
+Ip.prototype.delWhite = function (ip) {
+    if (typeof ip !== 'string') throw new TypeError('ip must be string');
+
+    const result = this._white.delete(ip);
+    if (result) {
+        this.logger('info', '删除白名单IP:', ip);
+    }
+    return result;
+};
+
+/**
+ * 从黑名单删除IP
+ * @param {string} ip - IP地址
+ * @returns {boolean} 是否删除成功
+ * @throws {TypeError} 当IP非字符串时
+ */
+Ip.prototype.delBlack = function (ip) {
+    if (typeof ip !== 'string') throw new TypeError('ip must be string');
+
+    const result = this._black.delete(ip);
+    if (result) {
+        this.logger('info', '删除黑名单IP:', ip);
+    }
+    return result;
+};
+
+/**
+ * 检查IP是否在白名单
+ * @param {string} ip - IP地址
+ * @returns {boolean} 是否在白名单
+ * @throws {TypeError} 当IP非字符串时
+ */
+Ip.prototype.isWhite = function (ip) {
+    if (typeof ip !== 'string') throw new TypeError('ip must be string');
+    return this._white.has(ip);
+};
+
+/**
+ * 检查IP是否在黑名单
+ * @param {string} ip - IP地址
+ * @returns {boolean} 是否在黑名单
+ * @throws {TypeError} 当IP非字符串时
+ */
+Ip.prototype.isBlack = function (ip) {
+    if (typeof ip !== 'string') throw new TypeError('ip must be string');
+    return this._black.has(ip);
+};
+
+/**
+ * 记录IP请求
+ * @param {string} ip - IP地址
+ * @returns {boolean} 是否允许请求
+ * @throws {TypeError} 当IP非字符串时
+ */
+Ip.prototype.record = function (ip) {
+    if (typeof ip !== 'string') throw new TypeError('ip must be string');
+
+    // 检查黑名单（包括过期检查）
+    if (this.isBlack(ip)) {
+        // 检查是否过期
+        if (this._isBlackExpired(ip)) {
+            this.delBlack(ip);
+            this.logger('info', '黑名单IP已过期，自动移除:', ip);
+        } else {
+            this.logger('warn', '黑名单IP请求被拒绝:', ip);
+            // 记录违规：黑名单IP尝试访问
+            if (this._config.violation_enable) {
+                this.recordViolation(ip, '黑名单IP尝试访问');
+            }
+            return false;
+        }
+    }
+
+    // 白名单直接通过
+    if (this.isWhite(ip)) {
+        this._updateReqCount(ip);
+        return true;
+    }
+
+    // 检查频率限制
+    if (!this._checkRateLimit(ip)) {
+        this.logger('warn', 'IP请求频率超限:', ip);
+
+        // 记录违规：请求频率超限
+        if (this._config.violation_enable) {
+            this.recordViolation(ip, '请求频率超限');
+        }
+
+        // 检查是否触发自动拉黑
+        if (this._config.auto_black_enable) {
+            const rate = this.getReqRate(ip);
+            if (rate >= this._config.auto_black_threshold) {
+                this._autoBlack(ip);
+                return false;
+            }
+        }
+
+        return false;
+    }
+
+    this._updateReqCount(ip);
+    return true;
+};
+
+/**
+ * 获取IP请求次数
+ * @param {string} ip - IP地址
+ * @returns {number} 请求次数
+ * @throws {TypeError} 当IP非字符串时
+ */
+Ip.prototype.getReqCount = function (ip) {
+    if (typeof ip !== 'string') throw new TypeError('ip must be string');
+    return this._req_count.get(ip) || 0;
+};
+
+/**
+ * 获取IP请求频率（每分钟请求数）
+ * @param {string} ip - IP地址
+ * @returns {number} 请求频率（每分钟请求数）
+ * @throws {TypeError} 当IP非字符串时
+ */
+Ip.prototype.getReqRate = function (ip) {
+    if (typeof ip !== 'string') throw new TypeError('ip must be string');
+
+    const now = Date.now();
+    const lastTime = this._req_time.get(ip) || now;
+    const count = this._req_count.get(ip) || 0;
+
+    if (now - lastTime < this._config.check_interval) {
+        // 在检查间隔内，计算实际频率
+        const elapsed = Math.max(1, now - lastTime); // 避免除零
+        return Math.round((count / elapsed) * this._config.check_interval);
+    } else {
+        // 超过检查间隔，频率为0
+        return 0;
+    }
+};
+
+/**
+ * 获取所有IP的请求统计信息
+ * @returns {Object} IP统计信息对象
+ */
+Ip.prototype.getAllStats = function () {
+    const stats = {};
+    const now = Date.now();
+
+    // 收集所有有请求记录的IP
+    for (const ip of this.getAllReqIps()) {
+        const lastTime = this._req_time.get(ip) || now;
+        const isActive = now - lastTime < this._config.check_interval;
+
+        stats[ip] = {
+            count: this.getReqCount(ip),
+            rate: isActive ? this.getReqRate(ip) : 0,
+            last_time: lastTime,
+            is_white: this.isWhite(ip),
+            is_black: this.isBlack(ip),
+            black_time: this.getBlackExpireTime(ip)
+        };
+    }
+
+    return stats;
+};
+
+/**
+ * 获取所有白名单IP
+ * @returns {Array} 白名单IP数组
+ */
+Ip.prototype.getAllWhite = function () {
+    return Array.from(this._white);
+};
+
+/**
+ * 获取所有黑名单IP
+ * @returns {Array} 黑名单IP数组
+ */
+Ip.prototype.getAllBlack = function () {
+    return Array.from(this._black);
+};
+
+/**
+ * 获取所有有请求记录的IP
+ * @returns {Array} 有请求记录的IP数组
+ */
+Ip.prototype.getAllReqIps = function () {
+    return Array.from(this._req_count.keys());
+};
+
+/**
+ * 清空白名单
+ */
+Ip.prototype.clearWhite = function () {
+    this._white.clear();
+    this.logger('info', '清空白名单');
+};
+
+/**
+ * 清空黑名单
+ */
+Ip.prototype.clearBlack = function () {
+    this._black.clear();
+    this.logger('info', '清空黑名单');
+};
+
+/**
+ * 清空所有请求记录
+ */
+Ip.prototype.clearReq = function () {
+    this._req_count.clear();
+    this._req_time.clear();
+    this.logger('info', '清空请求记录');
+};
+
+/**
+ * 检查IP请求频率限制（私有方法）
+ * @private
+ * @param {string} ip - IP地址
+ * @returns {boolean} 是否允许请求
+ */
+Ip.prototype._checkRateLimit = function (ip) {
+    const now = Date.now();
+    const lastTime = this._req_time.get(ip) || 0;
+
+    // 检查时间间隔
+    if (now - lastTime < this._config.check_interval) {
+        const count = this.getReqCount(ip);
+        if (count >= this._config.max_req_per_min) {
+            return false;
+        }
+    } else {
+        // 重置计数
+        this._req_count.set(ip, 0);
+    }
+
+    return true;
+};
+
+/**
+ * 更新IP请求计数（私有方法）
+ * @private
+ * @param {string} ip - IP地址
+ */
+Ip.prototype._updateReqCount = function (ip) {
+    const count = this.getReqCount(ip) + 1;
+    this._req_count.set(ip, count);
+    this._req_time.set(ip, Date.now());
+};
+
+/**
+ * 验证IP格式（私有方法）
+ * @private
+ * @param {string} ip - IP地址
+ * @returns {boolean} 是否有效IP
+ */
+Ip.prototype._validIp = function (ip) {
+    const ipRegex = /^(?:[0-9]{1,3}\.){3}[0-9]{1,3}$/;
+    return ipRegex.test(ip);
+};
+
+/**
+ * 批量添加IP到白名单
+ * @param {Array} ip_list - IP地址数组
+ * @returns {number} 成功添加的数量
+ */
+Ip.prototype.addWhiteBatch = function (ip_list) {
+    if (!Array.isArray(ip_list)) throw new TypeError('ip_list must be array');
+
+    let success = 0;
+    for (const ip of ip_list) {
+        if (typeof ip === 'string' && this._validIp(ip)) {
+            if (this.addWhite(ip)) {
+                success++;
+            }
+        }
+    }
+    return success;
+};
+
+/**
+ * 批量添加IP到黑名单
+ * @param {Array} ip_list - IP地址数组
+ * @returns {number} 成功添加的数量
+ */
+Ip.prototype.addBlackBatch = function (ip_list) {
+    if (!Array.isArray(ip_list)) throw new TypeError('ip_list must be array');
+
+    let success = 0;
+    for (const ip of ip_list) {
+        if (typeof ip === 'string' && this._validIp(ip)) {
+            if (this.addBlack(ip)) {
+                success++;
+            }
+        }
+    }
+    return success;
+};
+
+/**
+ * 手动高频拉黑IP
+ * @param {string} ip - IP地址
+ * @param {number} duration - 拉黑持续时间（毫秒）
+ * @returns {boolean} 是否拉黑成功
+ * @throws {TypeError} 当IP非字符串时
+ */
+Ip.prototype.blackByHighFreq = function (ip, duration) {
+    if (typeof ip !== 'string') throw new TypeError('ip must be string');
+
+    const black_duration = duration || this._config.auto_black_duration;
+
+    if (this.addBlack(ip)) {
+        this._black_time.set(ip, Date.now() + black_duration);
+        this.logger('warn', '手动高频拉黑IP:', ip, '持续时间:', black_duration + 'ms');
+        return true;
+    }
+
+    return false;
+};
+
+/**
+ * 检查并清理过期的黑名单IP（私有方法）
+ * @private
+ */
+Ip.prototype._cleanExpiredBlack = function () {
+    const now = Date.now();
+    const expired = [];
+
+    // 获取所有有过期时间的黑名单IP
+    for (const ip of this.getAllBlack()) {
+        const expireTime = this.getBlackExpireTime(ip);
+        if (expireTime && now > expireTime) {
+            expired.push(ip);
+        }
+    }
+
+    for (const ip of expired) {
+        this.delBlack(ip);
+        this._black_time.delete(ip);
+        this.logger('info', '清理过期黑名单IP:', ip);
+    }
+};
+
+/**
+ * 检查黑名单是否过期（私有方法）
+ * @private
+ * @param {string} ip - IP地址
+ * @returns {boolean} 是否过期
+ */
+Ip.prototype._isBlackExpired = function (ip) {
+    const expireTime = this.getBlackExpireTime(ip);
+    if (!expireTime) return false; // 没有设置过期时间，永不过期
+
+    return Date.now() > expireTime;
+};
+
+/**
+ * 自动拉黑IP（私有方法）
+ * @private
+ * @param {string} ip - IP地址
+ */
+Ip.prototype._autoBlack = function (ip) {
+    if (this.addBlack(ip)) {
+        this._black_time.set(ip, Date.now() + this._config.auto_black_duration);
+        this.logger('warn', '自动高频拉黑IP:', ip,
+            '频率:', this.getReqRate(ip) + '/分钟',
+            '持续时间:', this._config.auto_black_duration + 'ms');
+    }
+};
+
+/**
+ * 获取黑名单过期时间
+ * @param {string} ip - IP地址
+ * @returns {number|null} 过期时间戳（毫秒），null表示永不过期
+ * @throws {TypeError} 当IP非字符串时
+ */
+Ip.prototype.getBlackExpireTime = function (ip) {
+    if (typeof ip !== 'string') throw new TypeError('ip must be string');
+
+    if (!this.isBlack(ip)) return null;
+
+    const expireTime = this._black_time.get(ip);
+    return expireTime || null;
+};
+
+/**
+ * 清理所有过期的黑名单IP
+ * @returns {number} 清理的数量
+ */
+Ip.prototype.cleanExpiredBlack = function () {
+    const beforeCount = this.getAllBlack().length;
+    this._cleanExpiredBlack();
+    return beforeCount - this.getAllBlack().length;
+};
+
+/**
+ * 记录IP违规。
+ * @param {string} ip - IP地址
+ * @param {string} reason - 违规原因
+ * @returns {number} 当前违规次数
+ */
+Ip.prototype.recordViolation = function(ip, reason) {
+    if (typeof ip !== 'string') throw new TypeError('ip must be string');
+    if (!this._config.violation_enable) return 0;
+    
+    this._cleanExpiredViolation();
+    
+    const now = Date.now();
+    const count = this.getViolationCount(ip) + 1;
+    
+    this._violation_count.set(ip, count);
+    this._violation_time.set(ip, now);
+    
+    this.logger('info', 'IP违规记录:', { ip, reason, count, time: new Date(now).toISOString() });
+    
+    // 检查是否达到自动拉黑条件
+    if (this._config.violation_auto_black && count >= this._config.violation_max_count) {
+        this.blackByHighFreq(ip, this._config.auto_black_duration);
+        this.logger('warn', 'IP因违规次数超限自动拉黑:', { ip, count, duration: this._config.auto_black_duration });
+    }
+    
+    return count;
+};
+
+/**
+ * 获取IP违规次数。
+ * @param {string} ip - IP地址
+ * @returns {number} 违规次数
+ */
+Ip.prototype.getViolationCount = function(ip) {
+    if (typeof ip !== 'string') throw new TypeError('ip must be string');
+    
+    this._cleanExpiredViolation();
+    return this._violation_count.get(ip) || 0;
+};
+
+/**
+ * 重置IP违规记录。
+ * @param {string} ip - IP地址
+ * @returns {boolean} 是否成功重置
+ */
+Ip.prototype.resetViolation = function(ip) {
+    if (typeof ip !== 'string') throw new TypeError('ip must be string');
+    
+    const hadRecord = this._violation_count.has(ip);
+    this._violation_count.delete(ip);
+    this._violation_time.delete(ip);
+    
+    return hadRecord;
+};
+
+/**
+ * 获取所有有违规记录的IP
+ * @returns {Array} 有违规记录的IP数组
+ */
+Ip.prototype.getAllViolationIps = function() {
+    return Array.from(this._violation_count.keys());
+};
+
+/**
+ * 获取IP违规详细信息
+ * @param {string} ip - IP地址
+ * @returns {Object|null} 违规信息
+ */
+Ip.prototype.getViolationInfo = function(ip) {
+    if (typeof ip !== 'string') throw new TypeError('ip must be string');
+    
+    const count = this.getViolationCount(ip);
+    if (count === 0) return null;
+    
+    return {
+        count: count,
+        time: this._violation_time.get(ip)
+    };
+};
+
+/**
+ * 获取所有IP违规统计信息。
+ * @returns {Object} 违规统计信息
+ */
+Ip.prototype.getAllViolations = function() {
+    this._cleanExpiredViolation();
+    
+    const violations = {};
+    for (const ip of this.getAllViolationIps()) {
+        violations[ip] = this.getViolationInfo(ip);
+    }
+    
+    return violations;
+};
+
+/**
+ * 清理过期的违规记录（私有方法）
+ * @private
+ */
+Ip.prototype._cleanExpiredViolation = function() {
+    const now = Date.now();
+    const expired = [];
+
+    // 直接访问内部数据结构避免递归调用
+    for (const [ip, time] of this._violation_time) {
+        if (now - time > this._config.violation_reset_time) {
+            expired.push(ip);
+        }
+    }
+
+    for (const ip of expired) {
+        this._violation_count.delete(ip);
+        this._violation_time.delete(ip);
+    }
+};
+
+/**
+ * 清空所有违规记录
+ */
+Ip.prototype.clearViolations = function() {
+    this._violation_count.clear();
+    this._violation_time.clear();
+    this.logger('info', '清空所有违规记录');
+};
+
+/**
+ * 删除IP记录（从黑名单、白名单、临时记录中删除）
+ * @param {string} ip - IP地址
+ * @returns {Object} 删除结果
+ * @throws {TypeError} 当IP非字符串时
+ */
+Ip.prototype.del = function(ip) {
+    if (typeof ip !== 'string') throw new TypeError('ip must be string');
+    
+    const result = {
+        black: false,
+        white: false,
+        violation: false,
+        black_time: false,
+        violation_count: false,
+        violation_time: false
+    };
+    
+    // 从黑名单删除
+    if (this._black.has(ip)) {
+        this._black.delete(ip);
+        result.black = true;
+    }
+    
+    // 从白名单删除
+    if (this._white.has(ip)) {
+        this._white.delete(ip);
+        result.white = true;
+    }
+    
+    // 从违规记录删除
+    if (this._violation_count.has(ip)) {
+        this._violation_count.delete(ip);
+        result.violation_count = true;
+    }
+    
+    if (this._violation_time.has(ip)) {
+        this._violation_time.delete(ip);
+        result.violation_time = true;
+    }
+    
+    // 从黑名单过期时间记录删除
+    if (this._black_time.has(ip)) {
+        this._black_time.delete(ip);
+        result.black_time = true;
+    }
+    
+    // 如果有任何删除操作，记录日志
+    if (Object.values(result).some(Boolean)) {
+        this.logger('info', '删除IP记录:', { ip, result });
+    }
+    
+    return result;
+};
+
+if (global.$ && !$.ip) {
+    $.ip = new Ip();
+}
+
+module.exports = { Ip };

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "mm_ip",
+  "version": "1.0.0",
+  "description": "用于管理IP名单，可设置白名单、黑名单和IP检查，查询IP请求次数、频率等。",
+  "main": "index.js",
+  "scripts": {
+    "test": "node ./test.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://gitee.com/qiuwenwu91/mm_ip.git"
+  },
+  "keywords": [
+    "IP管理",
+    "白名单",
+    "黑名单",
+    "IP",
+    "IP请求次数",
+    "IP请求频率"
+  ],
+  "author": "qww",
+  "license": "ISC",
+  "dependencies": {
+    "mm_expand": "^1.9.7"
+  }
+}

package/test.js

@@ -0,0 +1,238 @@
+/**
+ * IP管理模块测试文件
+ */
+
+const { Ip } = require('./index.js');
+
+// 创建自定义日志器
+const logger = {
+    info: (...args) => console.log('[INFO]', ...args),
+    warn: (...args) => console.log('[WARN]', ...args),
+    error: (...args) => console.log('[ERROR]', ...args)
+};
+
+// 创建IP管理实例（启用高频拉黑和违规记录）
+const ip_manager = new Ip({
+    max_white: 5,
+    max_black: 5,
+    check_interval: 1000, // 1秒
+    max_req_per_min: 3,
+    auto_black_enable: true,
+    auto_black_threshold: 5, // 降低阈值便于测试
+    auto_black_duration: 5000, // 5秒便于测试
+    violation_enable: true, // 启用违规记录
+    violation_max_count: 3, // 降低阈值便于测试
+    violation_reset_time: 10000, // 10秒便于测试
+    violation_auto_black: true // 违规次数超限自动拉黑
+});
+
+// 设置自定义日志器
+ip_manager.setup(logger);
+
+console.log('=== IP管理模块测试开始 ===\n');
+
+// 测试1: 添加白名单
+console.log('1. 测试添加白名单:');
+console.log('添加 192.168.1.1:', ip_manager.addWhite('192.168.1.1'));
+console.log('添加 192.168.1.2:', ip_manager.addWhite('192.168.1.2'));
+console.log('添加 192.168.1.3:', ip_manager.addWhite('192.168.1.3'));
+console.log('白名单列表:', ip_manager.getAllWhite());
+
+// 测试2: 添加黑名单
+console.log('\n2. 测试添加黑名单:');
+console.log('添加 10.0.0.1:', ip_manager.addBlack('10.0.0.1'));
+console.log('添加 10.0.0.2:', ip_manager.addBlack('10.0.0.2'));
+console.log('黑名单列表:', ip_manager.getAllBlack());
+
+// 测试3: 检查IP状态
+console.log('\n3. 测试检查IP状态:');
+console.log('192.168.1.1 在白名单:', ip_manager.isWhite('192.168.1.1'));
+console.log('10.0.0.1 在黑名单:', ip_manager.isBlack('10.0.0.1'));
+console.log('192.168.1.100 在白名单:', ip_manager.isWhite('192.168.1.100'));
+
+// 测试4: 记录IP请求
+console.log('\n4. 测试记录IP请求:');
+console.log('白名单IP 192.168.1.1 请求:', ip_manager.record('192.168.1.1'));
+console.log('黑名单IP 10.0.0.1 请求:', ip_manager.record('10.0.0.1'));
+console.log('普通IP 172.16.0.1 请求:', ip_manager.record('172.16.0.1'));
+
+// 测试5: 测试频率限制
+console.log('\n5. 测试频率限制:');
+for (let i = 0; i < 5; i++) {
+    const result = ip_manager.record('172.16.0.2');
+    console.log(`第${i+1}次请求 172.16.0.2:`, result);
+}
+
+// 测试6: 获取请求次数
+console.log('\n6. 获取请求次数:');
+console.log('192.168.1.1 请求次数:', ip_manager.getReqCount('192.168.1.1'));
+console.log('172.16.0.1 请求次数:', ip_manager.getReqCount('172.16.0.1'));
+console.log('172.16.0.2 请求次数:', ip_manager.getReqCount('172.16.0.2'));
+
+// 测试7: 批量操作
+console.log('\n7. 测试批量操作:');
+const white_list = ['192.168.1.4', '192.168.1.5', '192.168.1.6'];
+const black_list = ['10.0.0.3', '10.0.0.4', '10.0.0.5'];
+console.log('批量添加白名单成功数:', ip_manager.addWhiteBatch(white_list));
+console.log('批量添加黑名单成功数:', ip_manager.addBlackBatch(black_list));
+console.log('当前白名单:', ip_manager.getAllWhite());
+console.log('当前黑名单:', ip_manager.getAllBlack());
+
+// 测试8: 删除操作
+console.log('\n8. 测试删除操作:');
+console.log('删除白名单 192.168.1.1:', ip_manager.delWhite('192.168.1.1'));
+console.log('删除黑名单 10.0.0.1:', ip_manager.delBlack('10.0.0.1'));
+console.log('删除后白名单:', ip_manager.getAllWhite());
+console.log('删除后黑名单:', ip_manager.getAllBlack());
+
+// 测试9: 错误处理
+console.log('\n9. 测试错误处理:');
+try {
+    ip_manager.addWhite(123); // 非字符串IP
+} catch (err) {
+    console.log('捕获错误:', err.message);
+}
+
+try {
+    ip_manager.addWhiteBatch('not_array'); // 非数组参数
+} catch (err) {
+    console.log('捕获错误:', err.message);
+}
+
+// 测试10: 清空操作
+console.log('\n10. 测试清空操作:');
+ip_manager.clearWhite();
+ip_manager.clearBlack();
+ip_manager.clearReq();
+console.log('清空后白名单:', ip_manager.getAllWhite());
+console.log('清空后黑名单:', ip_manager.getAllBlack());
+
+// 测试11: 高频拉黑功能
+console.log('\n11. 测试高频拉黑功能:');
+
+// 模拟高频请求触发自动拉黑
+console.log('模拟高频请求触发自动拉黑:');
+for (let i = 0; i < 10; i++) {
+    const result = ip_manager.record('192.168.100.1');
+    console.log(`第${i+1}次请求 192.168.100.1:`, result);
+}
+
+console.log('192.168.100.1 请求频率:', ip_manager.getReqRate('192.168.100.1') + '/分钟');
+console.log('192.168.100.1 是否在黑名单:', ip_manager.isBlack('192.168.100.1'));
+console.log('192.168.100.1 黑名单过期时间:', ip_manager.getBlackExpireTime('192.168.100.1'));
+
+// 测试手动高频拉黑
+console.log('\n测试手动高频拉黑:');
+console.log('手动拉黑 192.168.100.2:', ip_manager.blackByHighFreq('192.168.100.2', 10000));
+console.log('192.168.100.2 是否在黑名单:', ip_manager.isBlack('192.168.100.2'));
+console.log('192.168.100.2 黑名单过期时间:', ip_manager.getBlackExpireTime('192.168.100.2'));
+
+// 测试请求频率查询
+console.log('\n测试请求频率查询:');
+console.log('192.168.100.1 请求次数:', ip_manager.getReqCount('192.168.100.1'));
+console.log('192.168.100.1 请求频率:', ip_manager.getReqRate('192.168.100.1') + '次/分钟');
+
+// 测试获取所有统计信息
+console.log('\n测试获取所有统计信息:');
+const stats = ip_manager.getAllStats();
+console.log('统计信息中的IP数量:', Object.keys(stats).length);
+for (const ip in stats) {
+    if (ip === '192.168.100.1' || ip === '192.168.100.2') {
+        console.log(`${ip} 统计:`, stats[ip]);
+    }
+}
+
+// 测试过期清理
+console.log('\n测试过期清理:');
+console.log('清理前黑名单数量:', ip_manager.getAllBlack().length);
+setTimeout(() => {
+    console.log('等待6秒后清理过期黑名单...');
+    const cleaned = ip_manager.cleanExpiredBlack();
+    console.log('清理过期黑名单数量:', cleaned);
+    console.log('清理后黑名单数量:', ip_manager.getAllBlack().length);
+    
+    // 测试12: 违规记录功能
+    console.log('\n12. 测试违规记录功能:');
+    
+    // 测试黑名单IP尝试访问记录违规
+    console.log('测试黑名单IP尝试访问记录违规:');
+    ip_manager.addBlack('192.168.200.1');
+    console.log('黑名单IP 192.168.200.1 尝试访问:', ip_manager.record('192.168.200.1'));
+    console.log('192.168.200.1 违规次数:', ip_manager.getViolationCount('192.168.200.1'));
+    
+    // 测试频率超限记录违规
+    console.log('\n测试频率超限记录违规:');
+    for (let i = 0; i < 4; i++) {
+        const result = ip_manager.record('192.168.200.2');
+        console.log(`第${i+1}次请求 192.168.200.2:`, result);
+    }
+    console.log('192.168.200.2 违规次数:', ip_manager.getViolationCount('192.168.200.2'));
+    
+    // 测试手动记录违规
+    console.log('\n测试手动记录违规:');
+    console.log('手动记录 192.168.200.3 违规:', ip_manager.recordViolation('192.168.200.3', '手动测试违规'));
+    console.log('再次记录 192.168.200.3 违规:', ip_manager.recordViolation('192.168.200.3', '再次违规'));
+    console.log('192.168.200.3 违规次数:', ip_manager.getViolationCount('192.168.200.3'));
+    
+    // 测试违规次数超限自动拉黑
+    console.log('\n测试违规次数超限自动拉黑:');
+    console.log('第3次记录 192.168.200.3 违规:', ip_manager.recordViolation('192.168.200.3', '第三次违规'));
+    console.log('192.168.200.3 是否在黑名单:', ip_manager.isBlack('192.168.200.3'));
+    console.log('192.168.200.3 违规次数:', ip_manager.getViolationCount('192.168.200.3'));
+    
+    // 测试获取所有违规记录
+    console.log('\n测试获取所有违规记录:');
+    const violations = ip_manager.getAllViolations();
+    console.log('违规记录数量:', Object.keys(violations).length);
+    for (const ip in violations) {
+        console.log(`${ip} 违规记录:`, violations[ip]);
+    }
+    
+    // 测试重置违规记录
+    console.log('\n测试重置违规记录:');
+    console.log('重置 192.168.200.2 违规记录:', ip_manager.resetViolation('192.168.200.2'));
+    console.log('重置后 192.168.200.2 违规次数:', ip_manager.getViolationCount('192.168.200.2'));
+    
+    // 测试清空所有违规记录
+    console.log('\n测试清空所有违规记录:');
+    ip_manager.clearViolations();
+    console.log('清空后违规记录数量:', Object.keys(ip_manager.getAllViolations()).length);
+    
+    // 测试违规记录过期清理
+    console.log('\n测试违规记录过期清理:');
+    console.log('等待12秒后检查违规记录过期清理...');
+    setTimeout(() => {
+        console.log('过期清理后违规记录数量:', Object.keys(ip_manager.getAllViolations()).length);
+        
+        // 测试13: 删除IP记录功能
+        console.log('\n13. 测试删除IP记录功能:');
+        
+        // 准备测试数据
+        ip_manager.addBlack('192.168.300.1');
+        ip_manager.addWhite('192.168.300.1'); // 同时存在于黑白名单
+        ip_manager.recordViolation('192.168.300.1', '测试违规');
+        ip_manager.blackByHighFreq('192.168.300.1', 10000); // 设置过期时间
+        
+        console.log('删除前状态:');
+        console.log('192.168.300.1 在黑名单:', ip_manager.isBlack('192.168.300.1'));
+        console.log('192.168.300.1 在白名单:', ip_manager.isWhite('192.168.300.1'));
+        console.log('192.168.300.1 违规次数:', ip_manager.getViolationCount('192.168.300.1'));
+        console.log('192.168.300.1 黑名单过期时间:', ip_manager.getBlackExpireTime('192.168.300.1'));
+        
+        // 测试删除功能
+        const delResult = ip_manager.del('192.168.300.1');
+        console.log('删除结果:', delResult);
+        
+        console.log('删除后状态:');
+        console.log('192.168.300.1 在黑名单:', ip_manager.isBlack('192.168.300.1'));
+        console.log('192.168.300.1 在白名单:', ip_manager.isWhite('192.168.300.1'));
+        console.log('192.168.300.1 违规次数:', ip_manager.getViolationCount('192.168.300.1'));
+        console.log('192.168.300.1 黑名单过期时间:', ip_manager.getBlackExpireTime('192.168.300.1'));
+        
+        // 测试删除不存在的IP
+        const delNonExist = ip_manager.del('192.168.999.999');
+        console.log('删除不存在IP的结果:', delNonExist);
+        
+        console.log('\n=== IP管理模块测试结束 ===');
+    }, 12000);
+}, 6000);