DarkM

# Quartz 任务调度模块

Quartz 模块是 DarkM 框架的任务调度管理模块，基于 Quartz.NET 实现了可视化的定时任务管理系统。支持多种任务类型（代码任务、HTTP 任务）、丰富的触发器配置、执行日志记录等功能，满足各种定时任务需求。

# 📋 模块概述

属性 说明
模块名称 Quartz（任务调度）
模块类型 基础模块
依赖关系 依赖 Admin 模块
必需性 可选（推荐安装）
Git 仓库 framework/darkm/darkm (opens new window)

# 🎯 核心功能

# 功能清单

功能 说明 重要性
任务管理 定时任务的增删改查 ⭐⭐⭐⭐⭐
任务组管理 任务分组管理 ⭐⭐⭐⭐
代码任务 执行自定义代码任务 ⭐⭐⭐⭐⭐
HTTP 任务 执行 HTTP 请求任务 ⭐⭐⭐⭐⭐
触发器配置 Cron 表达式、简单触发器等 ⭐⭐⭐⭐⭐
任务控制 暂停、恢复、停止任务 ⭐⭐⭐⭐⭐
执行日志 详细的任务执行日志 ⭐⭐⭐⭐
日志清理 自动清理历史日志 ⭐⭐⭐

# 📦 安装配置

# NuGet 包安装

Install-Package DarkM.Module.Quartz.Web -Version 1.0.0
1

# NPM 包安装

npm i -S darkm-module-quartz
1

# 配置文件

{
  "Db": {
    "Modules": [
      {
        "Name": "Quartz",
        "Database": "Nm_Quartz",
        "Prefix": ""
      }
    ]
  },
  "Quartz": {
    // 是否开启任务调度
    "Enable": true,
    // 任务日志保留月数
    "LogKeepMonths": 3,
    // 是否开启日志自动清理
    "EnableLogAutoClear": true
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

配置说明：

配置项 说明 默认值
Enable 是否开启任务调度 true
LogKeepMonths 任务日志保留月数 3
EnableLogAutoClear 是否开启日志自动清理 true

# 🗄️ 数据库表结构

# 核心表

表名 说明 主键
Job 任务信息表 Id (Guid)
JobLog 任务执行日志表 Id (Guid)
JobHttp HTTP 任务配置表 Id (Guid)
Group 任务组表 Id (Guid)

# Quartz 系统表

表名 说明
QRTZ_CALENDARS Quartz 日历表
QRTZ_FIRED_TRIGGERS 已触发的触发器表
QRTZ_JOB_DETAILS 任务详细信息表
QRTZ_LOCKS 锁表
QRTZ_PAUSED_TRIGGER_GRPS 暂停的触发器组表
QRTZ_SCHEDULER_STATE 调度器状态表
QRTZ_SIMPLE_TRIGGERS 简单触发器表
QRTZ_SIMPROP_TRIGGERS 同步触发器表
QRTZ_TRIGGERS 触发器表

# 🔐 权限系统设计

# Controller 定义

using System;
using System.ComponentModel;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.ModelBinding;
using DarkM.Lib.Auth.Web.Attributes;
using DarkM.Lib.Utils.Core.Models;

namespace DarkM.Module.Quartz.Web.Controllers
{
    [Description("任务管理")]
    public class JobController : ModuleController
    {
        private readonly IJobService _service;

        public JobController(IJobService service)
        {
            _service = service;
        }

        [HttpGet]
        [Description("查询")]
        public Task<IResultModel> Query([FromQuery]JobQueryModel model)
        {
            return _service.Query(model);
        }

        [HttpPost]
        [Description("添加")]
        public Task<IResultModel> Add(JobAddModel model)
        {
            return _service.Add(model);
        }

        [HttpGet]
        [Description("编辑")]
        public Task<IResultModel> Edit([BindRequired]Guid id)
        {
            return _service.Edit(id);
        }

        [HttpPost]
        [Description("修改")]
        public Task<IResultModel> Update(JobUpdateModel model)
        {
            return _service.Update(model);
        }

        [HttpDelete]
        [Description("删除")]
        public Task<IResultModel> Delete([BindRequired]Guid id)
        {
            return _service.Delete(id);
        }

        [HttpPost]
        [Description("暂停")]
        public Task<IResultModel> Pause([BindRequired]Guid id)
        {
            return _service.Pause(id);
        }

        [HttpPost]
        [Description("恢复")]
        public Task<IResultModel> Resume([BindRequired]Guid id)
        {
            return _service.Resume(id);
        }

        [HttpPost]
        [Description("停止")]
        public Task<IResultModel> Stop([BindRequired]Guid id)
        {
            return _service.Stop(id);
        }

        [HttpGet]
        [Description("日志")]
        public Task<IResultModel> Log([FromQuery]JobLogQueryModel model)
        {
            return _service.Log(model);
        }

        [HttpPost]
        [Description("添加 HTTP 任务")]
        public Task<IResultModel> AddHttpJob(JobHttpAddModel model)
        {
            return _service.AddHttpJob(model);
        }

        [HttpGet]
        [Description("编辑 HTTP 任务")]
        public Task<IResultModel> EditHttpJob([BindRequired]Guid id)
        {
            return _service.EditHttpJob(id);
        }

        [HttpPost]
        [Description("修改 HTTP 任务")]
        public Task<IResultModel> UpdateHttpJob(JobHttpUpdateModel model)
        {
            return _service.UpdateHttpJob(model);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

# 权限解析结果

权限编码 说明 访问级别
quartz_job_query_get 任务管理 - 查询 需授权
quartz_job_add_post 任务管理 - 添加 需授权
quartz_job_edit_get 任务管理 - 编辑 需授权
quartz_job_update_post 任务管理 - 修改 需授权
quartz_job_delete_delete 任务管理 - 删除 需授权
quartz_job_pause_post 任务管理 - 暂停 需授权
quartz_job_resume_post 任务管理 - 恢复 需授权
quartz_job_stop_post 任务管理 - 停止 需授权
quartz_job_log_get 任务管理 - 日志 需授权
quartz_job_addhttpjob_post 任务管理 - 添加 HTTP 任务 需授权

# 🎨 核心功能详解

# 一、任务组管理

# 1. 创建任务组

public class GroupAddModel
{
    /// <summary>
    /// 组名称
    /// </summary>
    [Required]
    [Length(100)]
    public string Name { get; set; }

    /// <summary>
    /// 组编码
    /// </summary>
    [Required]
    [Length(50)]
    public string Code { get; set; }

    /// <summary>
    /// 描述
    /// </summary>
    [Length(500)]
    public string Description { get; set; }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

# 2. 任务组服务接口

public interface IGroupService
{
    /// <summary>
    /// 查询任务组列表
    /// </summary>
    Task<IResultModel> Query(GroupQueryModel model);

    /// <summary>
    /// 添加任务组
    /// </summary>
    Task<IResultModel> Add(GroupAddModel model);

    /// <summary>
    /// 删除任务组
    /// </summary>
    Task<IResultModel> Delete(Guid id);

    /// <summary>
    /// 获取下拉列表
    /// </summary>
    Task<IResultModel> Select();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

# 二、任务管理

# 1. 任务类型

类型 说明 适用场景
代码任务 执行自定义 C# 代码 数据处理、报表生成、文件清理等
HTTP 任务 执行 HTTP 请求 调用外部 API、Webhook 通知等

# 2. 创建代码任务

public class JobAddModel
{
    /// <summary>
    /// 任务名称
    /// </summary>
    [Required]
    [Length(100)]
    public string Name { get; set; }

    /// <summary>
    /// 任务组 ID
    /// </summary>
    [Required]
    public Guid GroupId { get; set; }

    /// <summary>
    /// 任务类型
    /// </summary>
    [Required]
    public JobType JobType { get; set; }

    /// <summary>
    /// 任务类名（代码任务）
    /// </summary>
    [Length(200)]
    public string JobClassName { get; set; }

    /// <summary>
    /// Cron 表达式
    /// </summary>
    [Length(100)]
    public string CronExpression { get; set; }

    /// <summary>
    /// 是否启用
    /// </summary>
    public bool Enabled { get; set; }

    /// <summary>
    /// 描述
    /// </summary>
    [Length(500)]
    public string Description { get; set; }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

# 3. 任务类型枚举

public enum JobType
{
    /// <summary>
    /// 代码任务
    /// </summary>
    Code = 0,

    /// <summary>
    /// HTTP 任务
    /// </summary>
    Http = 1
}
1
2
3
4
5
6
7
8
9
10
11
12

# 4. 任务控制

// 暂停任务
[HttpPost]
[Description("暂停")]
public Task<IResultModel> Pause([BindRequired]Guid id)
{
    return _service.Pause(id);
}

// 恢复任务
[HttpPost]
[Description("恢复")]
public Task<IResultModel> Resume([BindRequired]Guid id)
{
    return _service.Resume(id);
}

// 停止任务
[HttpPost]
[Description("停止")]
public Task<IResultModel> Stop([BindRequired]Guid id)
{
    return _service.Stop(id);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

# 三、HTTP 任务

# 1. HTTP 任务配置

public class JobHttpAddModel
{
    /// <summary>
    /// 任务 ID
    /// </summary>
    [Required]
    public Guid JobId { get; set; }

    /// <summary>
    /// 请求 URL
    /// </summary>
    [Required]
    [Length(500)]
    public string Url { get; set; }

    /// <summary>
    /// 请求方法
    /// </summary>
    [Required]
    public HttpMethod Method { get; set; }

    /// <summary>
    /// 请求头
    /// </summary>
    [Nullable]
    public string Headers { get; set; }

    /// <summary>
    /// 请求体
    /// </summary>
    [Nullable]
    public string Body { get; set; }

    /// <summary>
    /// 超时时间（秒）
    /// </summary>
    public int Timeout { get; set; } = 30;

    /// <summary>
    /// 认证类型
    /// </summary>
    public AuthType AuthType { get; set; }

    /// <summary>
    /// 认证 Token
    /// </summary>
    [Nullable]
    [Length(500)]
    public string AuthToken { get; set; }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

# 2. 请求方法枚举

public enum HttpMethod
{
    GET = 0,
    POST = 1,
    PUT = 2,
    DELETE = 3,
    PATCH = 4
}
1
2
3
4
5
6
7
8

# 3. 认证类型枚举

public enum AuthType
{
    /// <summary>
    /// 无认证
    /// </summary>
    None = 0,

    /// <summary>
    /// Bearer Token
    /// </summary>
    Bearer = 1,

    /// <summary>
    /// Basic Auth
    /// </summary>
    Basic = 2,

    /// <summary>
    /// API Key
    /// </summary>
    ApiKey = 3
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

# 四、任务日志

# 1. 日志查询

[HttpGet]
[Description("日志")]
public Task<IResultModel> Log([FromQuery]JobLogQueryModel model)
{
    return _service.Log(model);
}
1
2
3
4
5
6

# 2. 日志内容

字段 说明
JobId 任务 ID
JobName 任务名称
StartTime 开始时间
EndTime 结束时间
Duration 执行时长
Status 执行状态（成功/失败）
Message 执行消息
Exception 异常信息

# 3. 日志自动清理

/// <summary>
/// 移动 Job 日志到备份表，默认只保留 3 个月
/// </summary>
Task ClearJobLogSyncTask(int KeepMonths = 3);
1
2
3
4

# 🔧 核心服务接口

# IJobService（任务服务）

public interface IJobService
{
    /// <summary>
    /// 查询任务列表
    /// </summary>
    Task<IResultModel> Query(JobQueryModel model);

    /// <summary>
    /// 添加任务
    /// </summary>
    Task<IResultModel> Add(JobAddModel model);

    /// <summary>
    /// 编辑任务
    /// </summary>
    Task<IResultModel> Edit(Guid id);

    /// <summary>
    /// 更新任务
    /// </summary>
    Task<IResultModel> Update(JobUpdateModel model);

    /// <summary>
    /// 删除任务
    /// </summary>
    Task<IResultModel> Delete(Guid id);

    /// <summary>
    /// 暂停任务
    /// </summary>
    Task<IResultModel> Pause(Guid id);

    /// <summary>
    /// 恢复任务
    /// </summary>
    Task<IResultModel> Resume(Guid id);

    /// <summary>
    /// 停止任务
    /// </summary>
    Task<IResultModel> Stop(Guid id);

    /// <summary>
    /// 查询日志
    /// </summary>
    Task<IResultModel> Log(JobLogQueryModel model);

    /// <summary>
    /// 添加 HTTP 任务
    /// </summary>
    Task<IResultModel> AddHttpJob(JobHttpAddModel model);

    /// <summary>
    /// 编辑 HTTP 任务
    /// </summary>
    Task<IResultModel> EditHttpJob(Guid id);

    /// <summary>
    /// 更新 HTTP 任务
    /// </summary>
    Task<IResultModel> UpdateHttpJob(JobHttpUpdateModel model);

    /// <summary>
    /// HTTP 任务详情
    /// </summary>
    Task<IResultModel> JobHttpDetails(Guid id);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

# IGroupService（任务组服务）

public interface IGroupService
{
    /// <summary>
    /// 查询任务组列表
    /// </summary>
    Task<IResultModel> Query(GroupQueryModel model);

    /// <summary>
    /// 添加任务组
    /// </summary>
    Task<IResultModel> Add(GroupAddModel model);

    /// <summary>
    /// 删除任务组
    /// </summary>
    Task<IResultModel> Delete(Guid id);

    /// <summary>
    /// 获取下拉列表
    /// </summary>
    Task<IResultModel> Select();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

# 📊 使用流程

# 创建定时任务流程

1. 创建任务组（可选）
   ↓
2. 创建任务
   ↓
3. 配置触发器（Cron 表达式）
   ↓
4. 选择任务类型
   ├─ 代码任务：选择任务类
   └─ HTTP 任务：配置请求参数
   ↓
5. 启用任务
   ↓
6. 查看执行日志
   ↓
7. 完成✅
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

# 示例 1：创建每日数据清理任务

# 步骤 1：创建任务组

组名称：数据清理
组编码：DataClean
描述：负责各类数据清理任务
1
2
3

# 步骤 2：创建代码任务

任务名称：清理 3 个月前日志
任务组：数据清理
任务类型：代码任务
任务类：DataCleanJob.CleanLogJob
Cron 表达式：0 0 2 * * ?（每天凌晨 2 点执行）
启用：是
1
2
3
4
5
6

# 步骤 3：编写任务代码

using System.Threading.Tasks;
using DarkM.Lib.Quartz.Abstractions;

namespace DataCleanJob
{
    public class CleanLogJob : IJob
    {
        public async Task Execute(IJobExecutionContext context)
        {
            // 清理 3 个月前的日志
            var threeMonthsAgo = DateTime.Now.AddMonths(-3);
            
            // 清理操作日志
            await _auditLogService.DeleteAsync(m => m.CreateTime < threeMonthsAgo);
            
            // 清理登录日志
            await _loginLogService.DeleteAsync(m => m.CreateTime < threeMonthsAgo);
            
            Console.WriteLine($"日志清理完成，清理日期：{threeMonthsAgo}");
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

# 示例 2：创建 HTTP 通知任务

# 步骤 1：创建 HTTP 任务

任务名称：企业微信通知
任务组：消息通知
任务类型：HTTP 任务
1
2
3

# 步骤 2：配置 HTTP 请求

{
  "url": "https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=xxx",
  "method": "POST",
  "headers": "{\"Content-Type\":\"application/json\"}",
  "body": "{\"msgtype\":\"text\",\"text\":{\"content\":\"定时任务提醒\"}}",
  "timeout": 30,
  "authType": "None"
}
1
2
3
4
5
6
7
8

# 步骤 3：配置触发器

Cron 表达式：0 0 9 * * ?（每天早上 9 点执行）
启用：是
1
2

# 🖥️ 前端组件说明

# NPM 包信息

{
  "name": "darkm-module-quartz",
  "version": "1.5.0-beta-1.0",
  "code": "quartz",
  "title": "任务调度",
  "dependencies": {
    "darkm-module-admin": "^1.5.0-beta-1.0",
    "darkm-ui": "^1.5.0-beta-1.0"
  }
}
1
2
3
4
5
6
7
8
9
10

# 组件目录结构

src/UI/module-quartz/
├── src/
│   └── views/
│       ├── job/                    # 任务管理
│       │   ├── index/
│       │   │   ├── index.vue       # 任务列表页面
│       │   │   └── page.js         # 页面配置和路由
│       │   └── components/         # 任务管理子组件
│       │       ├── add/            # 添加任务
│       │       ├── edit-normal/    # 编辑代码任务
│       │       ├── edit-http/      # 编辑 HTTP 任务
│       │       ├── log-list/       # 任务日志
│       │       └── http-details/   # HTTP 任务详情
│       └── group/                  # 任务组管理
│           ├── index/
│           │   ├── index.vue       # 任务组列表页面
│           │   └── page.js         # 页面配置和路由
│           └── components/         # 任务组子组件
│               ├── add/            # 添加任务组
│               └── select/         # 任务组选择器
└── package.json
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

说明： Quartz 模块的组件主要组织在 views 目录下，每个功能模块包含：

  • index/ - 主页面组件
  • components/ - 子组件（弹窗、选择器等）

# 📦 页面组件详解

# 1. 任务管理页面

组件路径： views/job/index

功能： 定时任务管理主页面，支持任务增删改查、暂停/恢复/停止、日志查看

使用示例：

<template>
  <job-list />
</template>

<script>
import JobList from 'darkm-module-quartz/src/views/job/index'

export default {
  components: { JobList }
}
</script>
1
2
3
4
5
6
7
8
9
10
11

页面配置（page.js）：

const page = new (function() {
  this.title = '任务列表'
  this.icon = 'list'
  this.name = 'quartz_job'
  this.path = '/quartz/job'

  // 关联权限
  this.permissions = [`${this.name}_query_get`, `${this.name}_JobHttpDetails_get`]

  // 按钮配置
  this.buttons = {
    add: {
      text: '添加',
      type: 'success',
      icon: 'add',
      code: `${this.name}_add`,
      permissions: [`${this.name}_add_post`, `${this.name}_addhttpjob_post`]
    },
    edit: {
      text: '编辑',
      type: 'text',
      icon: 'edit',
      code: `${this.name}_edit`,
      permissions: [
        `${this.name}_edit_get`, 
        `${this.name}_update_post`,
        `${this.name}_edithttpjob_get`,
        `${this.name}_updatehttpjob_post`
      ]
    },
    pause: {
      text: '暂停',
      type: 'text',
      icon: 'pause',
      code: `${this.name}_pause`,
      permissions: [`${this.name}_pause_post`]
    },
    resume: {
      text: '启动',
      type: 'text',
      icon: 'run',
      code: `${this.name}_resume`,
      permissions: [`${this.name}_resume_post`]
    },
    stop: {
      text: '停止',
      type: 'text',
      icon: 'stop',
      code: `${this.name}_stop`,
      permissions: [`${this.name}_stop_post`]
    },
    log: {
      text: '日志',
      type: 'text',
      icon: 'log',
      code: `${this.name}_log`,
      permissions: [`${this.name}_log_get`]
    },
    del: {
      text: '删除',
      type: 'text',
      icon: 'delete',
      code: `${this.name}_del`,
      permissions: [`${this.name}_delete_delete`]
    }
  }
})()

export const route = {
  page,
  component: () => import(/* webpackChunkName: "Quartz.Job" */ './index')
}

export default page
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

子组件：

子组件路径 组件名称 功能
components/add 添加任务 支持添加代码任务和 HTTP 任务
components/edit-normal 编辑代码任务 编辑 Quartz 代码任务
components/edit-http 编辑 HTTP 任务 编辑 HTTP 请求任务
components/log-list 任务日志 查看任务执行历史
components/http-details HTTP 任务详情 查看 HTTP 任务配置详情
components/job-select 任务选择器 任务下拉选择

# 2. 任务组管理页面

组件路径： views/group/index

功能： 任务组管理主页面，支持任务组的添加、删除、选择

使用示例：

<template>
  <group-list />
</template>

<script>
import GroupList from 'darkm-module-quartz/src/views/group/index'

export default {
  components: { GroupList }
}
</script>
1
2
3
4
5
6
7
8
9
10
11

页面配置（page.js）：

const page = new (function() {
  this.title = '任务分组'
  this.icon = 'group'
  this.name = 'quartz_group'
  this.path = '/quartz/group'

  // 关联权限
  this.permissions = [`${this.name}_query_get`]

  // 按钮配置
  this.buttons = {
    add: {
      text: '添加',
      type: 'success',
      icon: 'add',
      code: `${this.name}_add`,
      permissions: [`${this.name}_add_post`]
    },
    del: {
      text: '删除',
      type: 'text',
      icon: 'delete',
      code: `${this.name}_del`,
      permissions: [`${this.name}_delete_delete`]
    }
  }
})()

export const route = {
  page,
  component: () => import(/* webpackChunkName: "Quartz.Group" */ './index')
}

export default page
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

子组件：

子组件路径 组件名称 功能
components/add 添加任务组 添加任务组弹窗
components/select 任务组选择器 任务组下拉选择

# 📋 组件使用注意事项

# 1. 组件引入方式

// 方式一：直接引入页面组件
import JobList from 'darkm-module-quartz/src/views/job/index'

// 方式二：通过模块引入
import Quartz from 'darkm-module-quartz'
Vue.use(Quartz)
1
2
3
4
5
6

# 2. 路由配置

在路由中配置模块页面：

import QuartzJob from 'darkm-module-quartz/src/views/job/index/page.js'

const routes = [
  {
    path: '/quartz/job',
    component: QuartzJob.route.component,
    meta: QuartzJob.page
  }
]
1
2
3
4
5
6
7
8
9

# 3. 权限配置

确保在 Admin 模块中配置对应权限：

// 任务管理权限
quartz_job_query_get      // 查询
quartz_job_add_post       // 添加
quartz_job_edit_get       // 编辑
quartz_job_update_post    // 修改
quartz_job_delete_delete  // 删除
quartz_job_pause_post     // 暂停
quartz_job_resume_post    // 恢复
quartz_job_stop_post      // 停止
quartz_job_log_get        // 日志
1
2
3
4
5
6
7
8
9
10

# 4. 组件依赖

Quartz 模块依赖以下模块：

  • darkm-module-admin - 权限管理
  • darkm-ui - UI 组件库

确保先安装依赖：

npm install darkm-module-admin --registry http://npm.woowis.com
npm install darkm-ui --registry http://npm.woowis.com
1
2

# 🔍 常见问题

# 🔍 常见问题

# 1. 任务不执行

问题： 任务创建后没有执行

解决：

# 检查 Quartz 是否启用
cat appsettings.json | grep -A 5 Quartz

# 检查任务是否启用
# 检查 Cron 表达式是否正确
# 检查任务类是否正确实现 IJob 接口

# 查看 Quartz 日志
tail -f logs/quartz.log
1
2
3
4
5
6
7
8
9

# 2. HTTP 任务请求失败

问题： HTTP 任务执行报错

解决：

  1. 检查 URL 是否正确
  2. 检查网络连接
  3. 检查认证信息是否正确
  4. 增加超时时间
  5. 查看任务日志中的异常信息

# 3. 任务日志过多

问题： JobLog 表数据量过大

解决：

// 开启日志自动清理
"Quartz": {
  "EnableLogAutoClear": true,
  "LogKeepMonths": 3  // 保留 3 个月
}

// 或手动清理
await _jobService.ClearJobLogSyncTask(3);
1
2
3
4
5
6
7
8

# 4. Cron 表达式不生效

问题： Cron 表达式配置后任务不执行

解决：

  1. 使用 Cron 表达式验证工具 (opens new window) 验证
  2. 检查时区设置
  3. 检查任务是否启用
  4. 重启服务后重试

# 📚 相关文档

# 🔗 参考链接

最后更新: 2026-03-20

← 04_HumanResources(人员管理) →