KeymouseGo定时任务：让脚本在指定时间自动运行

引言：告别手动操作的痛点

你是否还在为需要定时执行重复的鼠标键盘操作而烦恼？比如每天固定时间的报表生成、定时数据录入、周期性系统检查等任务，手动执行不仅耗时耗力，还容易出错。KeymouseGo作为一款类似按键精灵的自动化工具，虽然本身提供了强大的录制和回放功能，但默认并不支持定时任务功能。本文将详细介绍如何通过三种不同方案实现KeymouseGo脚本的定时自动运行，让你的自动化流程更加完善。

读完本文后，你将能够：

• 了解KeymouseGo的命令行接口和脚本执行原理
• 掌握使用系统任务计划程序（Windows）/Cron（Linux）实现定时运行的方法
• 学会编写Python定时任务脚本来调度KeymouseGo脚本
• 了解Docker容器化部署定时任务的方案
• 根据实际需求选择最适合的定时执行方案

KeymouseGo脚本执行原理

命令行接口解析

KeymouseGo提供了命令行接口（CLI）来执行录制好的脚本文件。通过分析KeymouseGo.py的源码，我们可以看到程序支持以下命令行参数：

parser.add_argument('scripts',
                    help='Path for the scripts',
                    type=str,
                    nargs='+'
                    )
parser.add_argument('-rt', '--runtimes',
                    help='Run times for the script',
                    type=int,
                    default=1
                    )

这意味着我们可以通过以下命令来执行脚本：

python KeymouseGo.py /path/to/your/script.txt -rt 3

其中：

• /path/to/your/script.txt 是录制好的脚本文件路径
• -rt 3 参数指定脚本运行3次（默认值为1，设置为0表示无限循环）

脚本执行流程

KeymouseGo的脚本执行主要由RunScriptClass和RunScriptCMDClass两个类实现。核心执行流程如下：

sequenceDiagram
    participant CLI
    participant RunScriptCMDClass
    participant ScriptParser
    participant EventExecutor
    participant PluginManager
    
    CLI->>RunScriptCMDClass: 启动线程执行脚本
    RunScriptCMDClass->>ScriptParser: 解析脚本文件
    ScriptParser->>RunScriptCMDClass: 返回事件集合
    loop 执行次数控制
        RunScriptCMDClass->>RunScriptCMDClass: 检查是否达到运行次数
        RunScriptCMDClass->>RunScriptCMDClass: 检查是否收到停止信号
        RunScriptCMDClass->>EventExecutor: 执行事件序列
        EventExecutor->>PluginManager: 调用插件（如有）
        PluginManager-->>EventExecutor: 返回插件执行结果
        EventExecutor-->>RunScriptCMDClass: 事件执行完成
    end
    RunScriptCMDClass->>CLI: 脚本执行完成

方案一：使用系统任务计划程序（Windows）

准备工作

1. 确保已经录制好需要定时执行的KeymouseGo脚本，并保存为.txt文件
2. 创建一个批处理文件（.bat）来调用KeymouseGo执行脚本

创建批处理文件

创建一个文本文件，将其重命名为run_keymouse_script.bat，内容如下：

@echo off
REM 切换到KeymouseGo程序目录
cd /d "C:\path\to\KeymouseGo"

REM 执行脚本，-rt 1表示运行1次
python KeymouseGo.py "C:\path\to\your\recorded_script.txt" -rt 1

REM 可选：执行完成后将日志输出到文件
echo Script executed at %date% %time% >> "C:\path\to\log.txt"

注意：请将上述路径替换为你实际的KeymouseGo程序路径和脚本文件路径

创建Windows任务计划

1. 按下Win + R组合键，输入taskschd.msc打开任务计划程序
2. 在右侧"操作"面板中，点击"创建基本任务..."
3. 按照向导提示设置任务名称和描述
4. 在"触发器"选项卡中，选择任务触发时间（每日、每周、每月或一次）
5. 在"操作"选项卡中，选择"启动程序"，并浏览选择之前创建的run_keymouse_script.bat文件
6. 完成向导并保存任务

高级定时设置

对于更复杂的定时需求，可以在任务属性中进行高级设置：

• 重复任务：设置任务在触发后每隔一段时间重复执行
• 持续时间：设置任务的有效执行期限
• 唤醒计算机：如果需要，可以配置任务唤醒计算机来执行
• 条件：设置任务执行的条件，如"只有在计算机使用交流电源时才执行"

方案二：使用Cron（Linux/macOS）

Cron任务基本格式

Cron任务的格式如下：

* * * * * command
- - - - -
| | | | |
| | | | +----- 星期几 (0 - 6) (星期天=0或7)
| | | +------- 月份 (1 - 12)
| | +--------- 日期 (1 - 31)
| +----------- 小时 (0 - 23)
+------------- 分钟 (0 - 59)

创建Cron任务

1. 创建一个Shell脚本文件run_keymouse_script.sh：

#!/bin/bash
# 切换到KeymouseGo程序目录
cd /path/to/KeymouseGo

# 执行脚本，-rt 1表示运行1次
python3 KeymouseGo.py "/path/to/your/recorded_script.txt" -rt 1

# 可选：执行完成后将日志输出到文件
echo "Script executed at $(date)" >> "/path/to/log.txt"

2. 为脚本添加可执行权限：

chmod +x run_keymouse_script.sh

3. 编辑crontab文件添加定时任务：

crontab -e

4. 添加以下行来设置每天早上8点执行脚本：

0 8 * * * /path/to/run_keymouse_script.sh

5. 保存并退出编辑器，Cron将自动应用新的任务设置

Cron任务管理常用命令

# 查看当前用户的Cron任务
crontab -l

# 编辑Cron任务
crontab -e

# 删除所有Cron任务
crontab -r

# 查看Cron服务状态
systemctl status cron  # 或 service cron status

方案三：Python定时任务脚本

方案原理

利用Python的sched模块或schedule库来实现定时调度，直接调用KeymouseGo的内部API来执行脚本，而无需通过命令行。

实现代码

创建一个名为keymouse_scheduler.py的文件，内容如下：

import time
import schedule
import threading
from Util.RunScriptClass import RunScriptCMDClass, StopFlag
from Event import ScriptEvent
from loguru import logger

class KeymouseScheduler:
    def __init__(self):
        self.stop_flag = StopFlag(False)
        self.script_path = "path/to/your/recorded_script.txt"
        self.running = False
        self.scheduler_thread = None
        
    def run_script(self):
        """执行KeymouseGo脚本"""
        logger.info(f"Starting scheduled script: {self.script_path}")
        try:
            # 创建执行线程
            runner = RunScriptCMDClass(
                script_path=self.script_path,
                run_times=1,  # 运行1次
                flag=self.stop_flag
            )
            runner.start()
            runner.wait()  # 等待执行完成
            logger.info(f"Script completed: {self.script_path}")
        except Exception as e:
            logger.error(f"Error executing script: {str(e)}")
            
    def job(self):
        """调度任务函数"""
        # 在新线程中执行脚本，避免阻塞调度器
        threading.Thread(target=self.run_script).start()
        
    def schedule_daily(self, hour, minute):
        """设置每天定时执行"""
        schedule.every().day.at(f"{hour:02d}:{minute:02d}").do(self.job)
        logger.info(f"Scheduled daily execution at {hour:02d}:{minute:02d}")
        
    def schedule_weekly(self, weekday, hour, minute):
        """设置每周定时执行"""
        # weekday: 0=周一, 6=周日
        schedule.every().week.do(self.job).at(f"{hour:02d}:{minute:02d}").\
            tag(f"weekly_{weekday}_{hour}_{minute}")
        logger.info(f"Scheduled weekly execution on weekday {weekday} at {hour:02d}:{minute:02d}")
            
    def start(self):
        """启动调度器"""
        self.running = True
        self.scheduler_thread = threading.Thread(target=self._run_scheduler)
        self.scheduler_thread.start()
        logger.info("Scheduler started")
        
    def stop(self):
        """停止调度器"""
        self.running = False
        self.stop_flag.value = True
        if self.scheduler_thread:
            self.scheduler_thread.join()
        logger.info("Scheduler stopped")
        
    def _run_scheduler(self):
        """调度器运行循环"""
        while self.running:
            schedule.run_pending()
            time.sleep(1)

if __name__ == "__main__":
    # 配置日志
    logger.add("keymouse_scheduler.log", rotation="10 MB")
    
    # 创建调度器实例
    scheduler = KeymouseScheduler()
    
    # 设置脚本路径
    scheduler.script_path = "path/to/your/recorded_script.txt"
    
    # 设置定时任务：每天8:30执行
    scheduler.schedule_daily(8, 30)
    
    # 启动调度器
    scheduler.start()
    
    # 保持主程序运行
    try:
        while True:
            time.sleep(1)
    except KeyboardInterrupt:
        scheduler.stop()

依赖安装

上述代码使用了schedule库来简化定时任务的实现，需要先安装：

pip install schedule loguru

使用方法

1. 将上述代码保存为keymouse_scheduler.py
2. 修改脚本中的script_path为你的KeymouseGo脚本路径
3. 根据需要设置定时任务（每日、每周等）
4. 运行脚本：python keymouse_scheduler.py

方案四：Docker容器化部署（适用于服务器环境）

Dockerfile编写

创建一个名为Dockerfile的文件：

FROM python:3.9-slim

WORKDIR /app

# 安装依赖
COPY requirements-windows.txt .
RUN pip install --no-cache-dir -r requirements-windows.txt

# 复制KeymouseGo程序文件
COPY . .

# 复制定时任务脚本
COPY keymouse_scheduler.py .

# 设置时区
ENV TZ=Asia/Shanghai

# 启动定时任务
CMD ["python", "keymouse_scheduler.py"]

构建和运行Docker镜像

# 构建镜像
docker build -t keymouse-scheduler .

# 运行容器
docker run -d --name keymouse-task keymouse-scheduler

Docker Compose部署

创建docker-compose.yml文件：

version: '3'

services:
  keymouse-scheduler:
    build: .
    container_name: keymouse-task
    volumes:
      - ./scripts:/app/scripts
      - ./logs:/app/logs
    environment:
      - TZ=Asia/Shanghai
    restart: always

使用Docker Compose启动服务：

docker-compose up -d

各方案对比与选择建议

方案	优点	缺点	适用场景
系统任务计划程序	无需额外安装软件，系统原生支持，可靠性高	配置不够灵活，跨平台性差	Windows桌面环境，简单定时需求
Cron任务	轻量级，系统原生支持，资源占用少	配置语法较复杂，缺乏图形界面	Linux/macOS服务器环境，稳定的定时任务
Python定时脚本	高度自定义，可灵活控制执行逻辑，跨平台	需要一定Python编程基础，需手动处理进程管理	复杂的定时逻辑，需要与其他系统集成
Docker容器化	环境隔离，部署简单，易于维护	有一定学习成本，资源占用相对较高	服务器环境，需要统一管理多个定时任务

选择建议

1. 普通桌面用户：优先选择系统任务计划程序（Windows）或Cron（Linux/macOS）
2. 开发者和高级用户：Python定时脚本提供了最大的灵活性和控制力
3. 服务器环境：Docker容器化部署便于管理和维护，适合长期运行

常见问题与解决方案

脚本执行失败

问题表现：任务计划显示执行成功，但脚本未实际运行

解决方案：

• 检查脚本路径和程序路径是否使用了绝对路径
• 在批处理文件中添加日志输出，便于排查问题
• 确保执行任务的用户具有足够的权限
• 尝试手动运行批处理文件或命令，检查是否能正常执行

定时任务不触发

问题表现：任务计划未按预期时间触发

解决方案：

• 检查系统时间是否正确
• 检查任务计划的触发条件设置是否正确
• 对于Windows任务计划，检查"条件"选项卡中的电源管理设置
• 查看任务计划的历史记录，了解任务未触发的原因

多脚本执行冲突

问题表现：多个KeymouseGo脚本同时执行导致操作混乱

解决方案：

• 合理安排任务时间，避免脚本同时执行
• 使用文件锁或进程间通信机制实现脚本执行互斥
• 在Python定时脚本中使用线程锁控制脚本执行顺序

# 在Python定时脚本中添加执行锁
from threading import Lock

class KeymouseScheduler:
    def __init__(self):
        # ... 其他初始化代码 ...
        self.execution_lock = Lock()
        
    def run_script(self):
        """执行KeymouseGo脚本，添加互斥锁"""
        if self.execution_lock.acquire(blocking=False):
            try:
                # ... 执行脚本代码 ...
            finally:
                self.execution_lock.release()
        else:
            logger.warning("Another script is already running, skipping execution")

KeymouseGo定时任务高级技巧

多脚本顺序执行

通过批处理文件或Shell脚本，可以实现多个KeymouseGo脚本的顺序执行：

# 多脚本顺序执行的Shell脚本示例
python KeymouseGo.py "script1.txt" -rt 1
python KeymouseGo.py "script2.txt" -rt 1
python KeymouseGo.py "script3.txt" -rt 1

条件执行脚本

结合简单的条件判断，可以实现更智能的脚本调度：

# Python脚本中的条件执行示例
import os
from datetime import datetime

def run_script_if_condition_met():
    # 检查当前时间是否在工作时间内
    hour = datetime.now().hour
    if 9 <= hour < 18:
        # 工作时间执行完整脚本
        runner = RunScriptCMDClass("full_script.txt", 1, StopFlag(False))
        runner.start()
        runner.wait()
    else:
        # 非工作时间执行简化脚本
        runner = RunScriptCMDClass("light_script.txt", 1, StopFlag(False))
        runner.start()
        runner.wait()

远程控制与监控

通过添加简单的网络接口，可以实现定时任务的远程控制与监控：

# 使用Flask添加简单的Web监控接口
from flask import Flask
import threading

app = Flask(__name__)
scheduler = None  # 全局调度器实例

@app.route('/status')
def get_status():
    """获取调度器状态"""
    return {
        "status": "running" if scheduler.running else "stopped",
        "next_run": str(schedule.next_run())
    }

@app.route('/run-now')
def run_now():
    """立即执行一次脚本"""
    threading.Thread(target=scheduler.run_script).start()
    return {"message": "Script execution started"}

if __name__ == "__main__":
    # ... 初始化调度器代码 ...
    
    # 启动Web服务
    threading.Thread(target=lambda: app.run(host='0.0.0.0', port=5000), daemon=True).start()
    
    # 启动调度器
    scheduler.start()

总结与展望

本文详细介绍了四种实现KeymouseGo定时任务的方案，从简单的系统工具到复杂的容器化部署，覆盖了不同用户的需求场景。通过这些方法，你可以将KeymouseGo的自动化能力扩展到时间维度，实现真正的无人值守自动化。

未来，我们期待KeymouseGo官方能够在软件中集成原生的定时任务功能，可能的实现方式包括：

classDiagram
    class MainWindow {
        +scheduleTask()
        +manageTasks()
    }
    
    class TaskScheduler {
        +addTask(script, time, repeat)
        +removeTask(id)
        +listTasks()
        +start()
        +stop()
    }
    
    class TaskStorage {
        +saveTasks(tasks)
        +loadTasks()
    }
    
    MainWindow --> TaskScheduler : controls
    TaskScheduler --> TaskStorage : uses
    TaskScheduler --> RunScriptClass : executes

无论采用哪种方案，定时任务都能极大地扩展KeymouseGo的自动化能力，帮助你更高效地完成重复劳动，释放宝贵的时间和精力。

附录：KeymouseGo安装与配置

安装步骤

1. 克隆项目仓库：

git clone https://gitcode.com/gh_mirrors/ke/KeymouseGo

2. 进入项目目录并安装依赖：

cd KeymouseGo
pip install -r requirements-windows.txt  # Windows系统
# 或
pip install -r requirements-universal.txt  # Linux/macOS系统

3. 运行KeymouseGo：

python KeymouseGo.py

基本使用流程

1. 点击"录制"按钮开始录制操作
2. 执行需要自动化的鼠标键盘操作
3. 点击"停止"按钮结束录制
4. 点击"保存"按钮将脚本保存为.txt文件
5. 使用本文介绍的定时方案之一来调度脚本执行