using Dapper;
|
using Microsoft.AspNetCore.Builder;
|
using Microsoft.AspNetCore.Hosting;
|
using Microsoft.Extensions.DependencyInjection;
|
using Newtonsoft.Json;
|
using Quartz;
|
using Quartz.Impl;
|
using Quartz.Impl.Matchers;
|
using Quartz.Impl.Triggers;
|
using Quartz.Spi;
|
using System;
|
using System.Collections.Generic;
|
using System.Linq;
|
using System.Threading.Tasks;
|
using VueWebCoreApi.Quartz;
|
using VueWebCoreApi.Tools;
|
|
namespace VueWebCoreApi.Extensions
|
{
|
/// <summary>
|
/// Quartz.NET 扩展方法类
|
/// 封装Quartz任务的初始化、增删改查、启停、立即执行等核心操作
|
/// 解决了Scheduler启动、内存与数据库状态同步、Cron表达式兼容、Key匹配等核心问题
|
/// </summary>
|
public static class QuartzNETExtension
|
{
|
/// <summary>
|
/// 全局返回信息对象（统一接口返回格式）
|
/// 包含code(状态码)、count(数量)、message(提示信息)、data(数据)
|
/// </summary>
|
public static ToMessage mes = new ToMessage();
|
/// <summary>
|
/// 内存级任务列表缓存
|
/// 用于减少数据库查询，同时保证内存与数据库状态一致
|
/// </summary>
|
private static List<TaskOptions> _taskList = new List<TaskOptions>();
|
|
/// <summary>
|
/// 扩展IApplicationBuilder，初始化Quartz任务调度器并加载所有任务
|
/// 【核心修复】解决Quartz默认不启动Scheduler的问题
|
/// </summary>
|
/// <param name="app">ASP.NET Core应用构建器</param>
|
/// <param name="env">Web主机环境</param>
|
/// <returns>应用构建器（链式调用）</returns>
|
public static IApplicationBuilder UseQuartz(this IApplicationBuilder app, IWebHostEnvironment env)
|
{
|
// 从DI容器获取依赖服务
|
var services = app.ApplicationServices;
|
// Quartz调度器工厂
|
var schedulerFactory = services.GetService<ISchedulerFactory>();
|
// 自定义Quartz仓储（数据库操作）
|
var quartzRepo = services.GetService<QuartzRepository>();
|
|
// 1. 核心修复：Quartz默认不会自动启动Scheduler，必须显式启动
|
var scheduler = schedulerFactory.GetScheduler().GetAwaiter().GetResult();
|
if (!scheduler.IsStarted)
|
{
|
scheduler.Start().GetAwaiter().GetResult();
|
}
|
// 2. 从数据库加载所有配置的任务
|
var taskList = quartzRepo.GetAllTasksAsync().GetAwaiter().GetResult();
|
if (taskList.Count == 0)
|
{
|
//无任务时记录启动日志
|
quartzRepo.WriteStartLogAsync($"{DateTime.Now:yyyy-MM-dd HH:mm:ss},没有默认配置任务").GetAwaiter().GetResult();
|
return app;
|
}
|
// 3. 遍历任务并初始化（记录失败数和异常信息）
|
int errorCount = 0;
|
string errorMsg = string.Empty;
|
// 初始化内存任务列表
|
_taskList = taskList;
|
|
foreach (var task in taskList)
|
{
|
try
|
{
|
//var result = task.AddJob(schedulerFactory, true, services.GetService<IJobFactory>()).GetAwaiter().GetResult();
|
// 调用TaskOptions的AddJob方法添加任务到调度器
|
// 传入仓储用于数据库操作，传入JobFactory用于自定义Job实例化
|
var result = task.AddJob(schedulerFactory, true, services.GetService<IJobFactory>(), quartzRepo).GetAwaiter().GetResult();
|
}
|
catch (Exception ex)
|
{
|
// 记录单个任务初始化失败信息
|
errorCount++;
|
errorMsg += $"作业:{task.TaskName},异常：{ex.Message};";
|
}
|
}
|
// 4. 记录整体初始化结果日志
|
var content = $"成功:{taskList.Count - errorCount}个,失败{errorCount}个,异常：{errorMsg}";
|
quartzRepo.WriteStartLogAsync($"{DateTime.Now:yyyy-MM-dd HH:mm:ss},{content}").GetAwaiter().GetResult();
|
|
return app;
|
}
|
|
/// <summary>
|
/// 获取调度器中所有任务，并同步内存/数据库状态（核心修复：解决内存列表与数据库不一致问题）
|
/// </summary>
|
/// <param name="schedulerFactory">调度器工厂</param>
|
/// <param name="quartzRepo">Quartz仓储</param>
|
/// <returns>最新的任务列表</returns>
|
public static async Task<List<TaskOptions>> GetJobs(this ISchedulerFactory schedulerFactory, QuartzRepository quartzRepo)
|
{
|
var list = new List<TaskOptions>();
|
try
|
{
|
var scheduler = await schedulerFactory.GetScheduler();
|
// 确保Scheduler处于启动状态（防御性编程）
|
if (!scheduler.IsStarted) await scheduler.Start();
|
// 1. 获取所有任务分组（Quartz任务按分组管理）
|
var groups = await scheduler.GetJobGroupNames();
|
|
foreach (var groupName in groups)
|
{
|
// 2. 获取分组下所有JobKey（任务唯一标识：名称+分组）
|
var jobKeys = await scheduler.GetJobKeys(GroupMatcher<JobKey>.GroupEquals(groupName));
|
foreach (var jobKey in jobKeys)
|
{
|
// 3. 核心修复：优先从数据库获取最新任务（避免内存数据过期）
|
var dbTask = await quartzRepo.TaskExists(jobKey.Name, jobKey.Group);
|
// 数据库无数据时，降级从内存列表获取
|
var task = dbTask.FirstOrDefault() ?? _taskList.FirstOrDefault(x => x.GroupName == jobKey.Group && x.TaskName == jobKey.Name);
|
// 过滤无效任务
|
if (task == null) continue;
|
// 4. 获取任务关联的触发器（Quartz任务通过触发器触发执行）
|
var triggers = await scheduler.GetTriggersOfJob(jobKey);
|
foreach (var trigger in triggers)
|
{
|
// 5. 同步触发器实际状态到任务对象，并更新到数据库
|
task.Status = (int)await scheduler.GetTriggerState(trigger.Key);
|
await quartzRepo.UpdateTaskAsync(task); // 状态同步到库
|
// 6. 同步任务最后执行时间
|
if (trigger.GetPreviousFireTimeUtc() != null)
|
{
|
// 优先从触发器获取最后执行时间（UTC转本地时间）
|
task.LastRunTime = trigger.GetPreviousFireTimeUtc()?.LocalDateTime;
|
await quartzRepo.UpdateTaskLastRunTimeAsync(task.TaskName, task.GroupName, task.LastRunTime.Value);
|
}
|
else
|
{
|
// 触发器无记录时，从执行日志中获取最后执行时间
|
var logs = await quartzRepo.GetJobRunLogAsync(task.TaskName, task.GroupName, 1, 1);
|
if (logs.Count > 0 && DateTime.TryParse(logs[0].BeginDate, out var lastRunTime))
|
{
|
task.LastRunTime = lastRunTime;
|
await quartzRepo.UpdateTaskLastRunTimeAsync(task.TaskName, task.GroupName, lastRunTime);
|
}
|
}
|
}
|
list.Add(task);
|
}
|
}
|
// 7. 同步内存列表为最新数据（保证后续操作使用最新状态）
|
_taskList = list;
|
}
|
catch (Exception ex)
|
{
|
mes.code = "300";
|
mes.count = 0;
|
mes.message = ex.Message + ex.StackTrace;
|
mes.data = null;
|
await quartzRepo.WriteStartLogAsync($"获取作业异常：{ex.Message}{ex.StackTrace}");
|
return new List<TaskOptions>();
|
}
|
return list;
|
}
|
|
/// <summary>
|
/// 新增Quartz任务（初始化/手动添加通用）
|
/// </summary>
|
/// <param name="task">任务配置项</param>
|
/// <param name="schedulerFactory">调度器工厂</param>
|
/// <param name="init">是否为初始化阶段（初始化时不重复入库）</param>
|
/// <param name="jobFactory">Job工厂（自定义Job实例化逻辑）</param>
|
/// <param name="quartzRepo">Quartz仓储</param>
|
/// <returns>统一返回结果（ToMessage）</returns>
|
public static async Task<object> AddJob(this TaskOptions task, ISchedulerFactory schedulerFactory, bool init = false, IJobFactory jobFactory = null, QuartzRepository quartzRepo = null)
|
{
|
try
|
{
|
// 1. 修复前端传入的Cron表达式兼容性问题
|
task.Interval = FixCronExpression(task.Interval);
|
// 2. 验证Cron表达式有效性
|
var (isValid, msg) = task.Interval.IsValidExpression();
|
if (!isValid)
|
return new ToMessage { code = "300", count = 0, message = msg, data = null };
|
// 3. 非初始化阶段：校验任务是否已存在（避免重复添加）
|
if (!init && await quartzRepo.TaskExistsAsync(task.TaskName, task.GroupName))
|
{
|
return new ToMessage { code = "300", count = 0, message = $"作业:{task.TaskName},分组：{task.GroupName}已经存在", data = null };
|
}
|
// 4. 非初始化阶段：新增任务到内存+数据库+记录操作日志
|
if (!init)
|
{
|
_taskList.Add(task);// 内存添加
|
await quartzRepo.CreateTaskAsync(task);// 数据库添加
|
await quartzRepo.AddJobActionLogAsync(JobAction.新增.ToString(), task.TaskName, task.GroupName, "新增任务成功");// 操作日志
|
}
|
// 5. 构建Quartz Job（任务执行体）
|
var job = JobBuilder.Create<HttpResultfulJob>()// HttpResultfulJob：自定义的HTTP请求型Job
|
.WithIdentity(task.TaskName, task.GroupName)// 设置Job唯一标识（名称+分组）
|
.Build();
|
|
// 6. 构建Cron触发器（按Cron表达式触发）
|
var trigger = TriggerBuilder.Create()
|
.WithIdentity(task.TaskName, task.GroupName)// 触发器唯一标识（与Job保持一致）
|
.StartNow()// 立即启动
|
.WithDescription(task.Describe)// 任务描述
|
.WithCronSchedule(task.Interval)// 绑定Cron表达式
|
.Build();
|
|
// 7. 获取调度器并确保启动
|
var scheduler = await schedulerFactory.GetScheduler();
|
if (!scheduler.IsStarted) await scheduler.Start(); // 确保启动
|
// 8. 设置自定义JobFactory（如需控制Job的依赖注入/实例化）
|
if (jobFactory != null)
|
{
|
scheduler.JobFactory = jobFactory;
|
}
|
|
// 9. 将Job和触发器绑定到调度器
|
await scheduler.ScheduleJob(job, trigger);
|
|
// 10. 根据任务状态设置触发器启停
|
if (task.Status == (int)TriggerState.Normal)
|
{
|
await scheduler.ResumeTrigger(trigger.Key);// 显式恢复（确保触发器正常运行）
|
}
|
else
|
{
|
await scheduler.PauseJob(job.Key);// 暂停任务
|
await quartzRepo.WriteStartLogAsync($"作业:{task.TaskName},分组:{task.GroupName},新建时未启动原因,状态为:{task.Status}");
|
}
|
mes.code = "200";
|
mes.count = 0;
|
mes.message = "执行成功！";
|
mes.data = null;
|
}
|
catch (Exception ex)
|
{
|
return new ToMessage { code = "300", count = 0, message = ex.Message, data = null };
|
}
|
return mes;
|
}
|
|
/// <summary>
|
/// 移除（删除）任务
|
/// </summary>
|
/// <param name="schedulerFactory">调度器工厂</param>
|
/// <param name="task">任务配置</param>
|
/// <param name="quartzRepo">Quartz仓储</param>
|
/// <returns>操作结果</returns>
|
public static Task<object> Remove(this ISchedulerFactory schedulerFactory, TaskOptions task, QuartzRepository quartzRepo)
|
{
|
return TriggerAction(schedulerFactory, task.TaskName, task.GroupName, JobAction.删除, task, quartzRepo);
|
}
|
|
/// <summary>
|
/// 修改任务配置
|
/// </summary>
|
/// <param name="schedulerFactory">调度器工厂</param>
|
/// <param name="task">新的任务配置</param>
|
/// <param name="quartzRepo">Quartz仓储</param>
|
/// <returns>操作结果</returns>
|
public static Task<object> Update(this ISchedulerFactory schedulerFactory, TaskOptions task, QuartzRepository quartzRepo)
|
{
|
return TriggerAction(schedulerFactory, task.TaskName, task.GroupName, JobAction.修改, task, quartzRepo);
|
}
|
|
/// <summary>
|
/// 暂停任务
|
/// </summary>
|
/// <param name="schedulerFactory">调度器工厂</param>
|
/// <param name="task">任务配置</param>
|
/// <param name="quartzRepo">Quartz仓储</param>
|
/// <returns>操作结果</returns>
|
public static Task<object> Pause(this ISchedulerFactory schedulerFactory, TaskOptions task, QuartzRepository quartzRepo)
|
{
|
return TriggerAction(schedulerFactory, task.TaskName, task.GroupName, JobAction.暂停, task, quartzRepo);
|
}
|
|
/// <summary>
|
/// 启动（恢复）任务
|
/// </summary>
|
/// <param name="schedulerFactory">调度器工厂</param>
|
/// <param name="task">任务配置</param>
|
/// <param name="quartzRepo">Quartz仓储</param>
|
/// <returns>操作结果</returns>
|
public static Task<object> Start(this ISchedulerFactory schedulerFactory, TaskOptions task, QuartzRepository quartzRepo)
|
{
|
return TriggerAction(schedulerFactory, task.TaskName, task.GroupName, JobAction.开启, task, quartzRepo);
|
}
|
|
/// <summary>
|
/// 立即执行任务（无视Cron表达式）
|
/// </summary>
|
/// <param name="schedulerFactory">调度器工厂</param>
|
/// <param name="task">任务配置</param>
|
/// <param name="quartzRepo">Quartz仓储</param>
|
/// <returns>操作结果</returns>
|
public static Task<object> Run(this ISchedulerFactory schedulerFactory, TaskOptions task, QuartzRepository quartzRepo)
|
{
|
return TriggerAction(schedulerFactory, task.TaskName, task.GroupName, JobAction.立即执行, task, quartzRepo);
|
}
|
|
/// <summary>
|
/// 任务操作核心逻辑（核心修复：Key匹配+状态同步+Scheduler启动校验）
|
/// 封装删除/修改/暂停/开启/立即执行的通用逻辑，避免代码冗余
|
/// </summary>
|
/// <param name="schedulerFactory">调度器工厂</param>
|
/// <param name="taskName">任务名称</param>
|
/// <param name="groupName">分组名称</param>
|
/// <param name="action">操作类型（删除/修改/暂停/开启/立即执行）</param>
|
/// <param name="task">任务配置</param>
|
/// <param name="quartzRepo">Quartz仓储</param>
|
/// <returns>操作结果</returns>
|
private static async Task<object> TriggerAction(this ISchedulerFactory schedulerFactory, string taskName, string groupName, JobAction action, TaskOptions task, QuartzRepository quartzRepo)
|
{
|
try
|
{
|
// 1. 预处理Cron表达式（修复前端传入的表达式）
|
if (task != null) task.Interval = FixCronExpression(task.Interval);
|
|
// 2. 获取调度器并确保启动（核心修复1：全局Scheduler启动校验）
|
var scheduler = await schedulerFactory.GetScheduler();
|
// 核心修复1：确保Scheduler全局启动
|
if (!scheduler.IsStarted) await scheduler.Start();
|
|
// 3. 核心修复2：正确构建JobKey（任务名+分组），解决Key匹配失败问题
|
var jobKey = new JobKey(taskName, groupName);
|
if (!await scheduler.CheckExists(jobKey))
|
{
|
return new ToMessage { code = "300", count = 0, message = $"未找到任务[{taskName}-{groupName}]", data = null };
|
}
|
|
// 4. 获取任务关联的触发器（无触发器则任务无法执行）
|
var triggers = await scheduler.GetTriggersOfJob(jobKey);
|
if (triggers == null || !triggers.Any())
|
{
|
return new ToMessage { code = "300", count = 0, message = $"任务[{taskName}-{groupName}]无触发器", data = null };
|
}
|
// 取第一个触发器（单任务默认绑定一个触发器）
|
var trigger = triggers.First();
|
|
object result = null;
|
// 5. 根据操作类型执行不同逻辑
|
switch (action)
|
{
|
case JobAction.删除:
|
// 暂停触发器 -> 解绑触发器 -> 删除Job -> 同步内存+数据库 -> 记录日志
|
await scheduler.PauseTrigger(trigger.Key);
|
await scheduler.UnscheduleJob(trigger.Key);
|
await scheduler.DeleteJob(jobKey);
|
_taskList.RemoveAll(x => x.TaskName == taskName && x.GroupName == groupName);
|
await quartzRepo.DeleteTaskAsync(taskName, groupName);
|
await quartzRepo.AddJobActionLogAsync(action.ToString(), taskName, groupName, "删除任务成功");
|
break;
|
|
case JobAction.修改:
|
// 修改逻辑：先删除旧任务 -> 重新添加新配置 -> 记录日志
|
await scheduler.PauseTrigger(trigger.Key);
|
await scheduler.UnscheduleJob(trigger.Key);
|
await scheduler.DeleteJob(jobKey);
|
_taskList.RemoveAll(x => x.TaskName == taskName && x.GroupName == groupName);
|
await quartzRepo.DeleteTaskAsync(taskName, groupName);
|
result = await task.AddJob(schedulerFactory, false, null, quartzRepo);// 重新添加任务
|
await quartzRepo.AddJobActionLogAsync(action.ToString(), taskName, groupName, JsonConvert.SerializeObject(task));
|
break;
|
|
case JobAction.暂停:
|
// 暂停触发器 -> 更新任务状态 -> 同步内存+数据库 -> 记录日志
|
await scheduler.PauseTrigger(trigger.Key);
|
task.Status = (int)TriggerState.Paused;
|
await quartzRepo.UpdateTaskAsync(task);
|
_taskList.RemoveAll(x => x.TaskName == taskName && x.GroupName == groupName);
|
_taskList.Add(task); // 同步内存状态
|
await quartzRepo.AddJobActionLogAsync(action.ToString(), taskName, groupName, "暂停任务成功");
|
break;
|
|
case JobAction.开启:
|
// 恢复触发器 -> 更新任务状态 -> 同步内存+数据库 -> 记录日志
|
await scheduler.ResumeTrigger(trigger.Key);
|
task.Status = (int)TriggerState.Normal;
|
await quartzRepo.UpdateTaskAsync(task);
|
_taskList.RemoveAll(x => x.TaskName == taskName && x.GroupName == groupName);
|
_taskList.Add(task); // 同步内存状态
|
await quartzRepo.AddJobActionLogAsync(action.ToString(), taskName, groupName, "开启任务成功");
|
break;
|
|
case JobAction.立即执行:
|
// 立即执行前确保任务处于启动状态 -> 触发Job立即执行 -> 记录日志
|
if (task.Status != (int)TriggerState.Normal)
|
{
|
task.Status = (int)TriggerState.Normal;
|
await quartzRepo.UpdateTaskAsync(task);
|
_taskList.RemoveAll(x => x.TaskName == taskName && x.GroupName == groupName);
|
_taskList.Add(task);
|
await scheduler.ResumeTrigger(trigger.Key);
|
}
|
await scheduler.TriggerJob(jobKey); // 立即触发任务执行
|
await quartzRepo.AddJobActionLogAsync(action.ToString(), taskName, groupName, "立即执行任务成功");
|
break;
|
}
|
mes.code = "200";
|
mes.count = 0;
|
mes.message = $"作业{action.ToString()}成功";
|
mes.data = null;
|
return result ?? mes;
|
}
|
catch (Exception ex)
|
{
|
await quartzRepo.AddJobActionLogAsync(action.ToString(), taskName, groupName, $"操作失败：{ex.Message}");
|
return new ToMessage { code = "300", count = 0, message = ex.Message, data = null };
|
}
|
}
|
|
/// <summary>
|
/// 修复前端传入的Cron表达式缺陷
|
/// 兼容ASP.NET Core 3.1中Cron表达式的Day/Week字段写法问题
|
/// </summary>
|
/// <param name="cron">原始Cron表达式</param>
|
/// <returns>修复后的Cron表达式</returns>
|
private static string FixCronExpression(string cron)
|
{
|
if (string.IsNullOrEmpty(cron))
|
return cron;
|
|
// 拆分Cron表达式（标准Cron：秒 分 时 日 月 周 年（可选））
|
var str = cron.Split(" ", StringSplitOptions.RemoveEmptyEntries);
|
if (str.Length < 6)
|
return cron;
|
|
// 兼容 ASP.NET Core 3.1 的写法（替换 or 语法）
|
// 修复场景：Day字段为1L/2L...7L 且 周字段为? 时，交换Day和周字段
|
// 原因：前端可能混淆了Day/周字段的写法，Quartz对L（最后一天）的解析有特定规则
|
var dayValue = str[3];// 第4个字段：Day
|
if ((dayValue == "1L" || dayValue == "2L" || dayValue == "3L" ||
|
dayValue == "4L" || dayValue == "5L" || dayValue == "6L" || dayValue == "7L") && str[5] == "?")
|
{
|
str[5] = str[3]; // 周字段 = 原Day字段
|
str[3] = "?"; // Day字段 = ?
|
return string.Join(" ", str);
|
}
|
|
return cron;
|
}
|
|
/// <summary>
|
/// 验证Cron表达式是否有效
|
/// </summary>
|
/// <param name="cronExpression">Cron表达式</param>
|
/// <returns>是否有效 + 错误信息</returns>
|
public static (bool, string) IsValidExpression(this string cronExpression)
|
{
|
try
|
{
|
// 通过Quartz内置的CronTriggerImpl验证表达式
|
var trigger = new CronTriggerImpl();
|
trigger.CronExpressionString = cronExpression;
|
// 计算第一个触发时间：null表示表达式无效
|
var date = trigger.ComputeFirstFireTimeUtc(null);
|
return (date != null, date == null ? $"表达式{cronExpression}无效!" : string.Empty);
|
}
|
catch (Exception e)
|
{
|
return (false, $"表达式{cronExpression}无效!{e.Message}");
|
}
|
}
|
|
/// <summary>
|
/// 从Job执行上下文获取任务配置
|
/// 用于Job执行时获取最新的任务参数
|
/// </summary>
|
/// <param name="context">Job执行上下文</param>
|
/// <returns>任务配置项</returns>
|
public static TaskOptions GetTaskOptions(this IJobExecutionContext context)
|
{
|
var jobKey = context.JobDetail.Key;
|
// 从内存列表中获取匹配的任务（Job执行时优先用内存，减少数据库查询）
|
return _taskList.FirstOrDefault(x => x.TaskName == jobKey.Name && x.GroupName == jobKey.Group);
|
}
|
}
|
}
|
