public async Task <JobKey> ScheduleJob <T>(DateTimeOffset?startAtTime = null, JobKey?vncCheckerJobKey = null)
where T : class, IJob
{
IScheduler scheduler = await StdSchedulerFactory.GetDefaultScheduler();
await scheduler.Start();
IJobDetail jobDetail = JobBuilder.Create <T>().Build();
ITrigger trigger;
TriggerBuilder triggerBuilder = TriggerBuilder.Create().StartNow()
.WithSimpleSchedule(x => x.WithIntervalInSeconds(Constants.JobEecutionIntervalSec)
.RepeatForever());
if (vncCheckerJobKey != null)
{
triggerBuilder = triggerBuilder.UsingJobData(nameof(Checker), vncCheckerJobKey.Name);
}
if (startAtTime != null)
{
trigger = triggerBuilder.StartAt((DateTimeOffset)startAtTime).Build();
}
else
{
trigger = triggerBuilder.StartNow().Build();
}
await scheduler.ScheduleJob(jobDetail, trigger);
return(jobDetail.Key);
}
public async Task <DateTimeOffset?> ScheduleRemoveOldEventsJob(int intervalSecs, DateTime?startAt)
{
ValidateRemoveOldEventsJobSchedule();
TriggerBuilder builder = TriggerBuilder.Create()
.WithIdentity(RemoveOldEventsTriggerKey);
if (startAt != null)
{
builder = builder.StartAt(startAt.Value);
}
else
{
builder = builder.StartNow();
}
builder = builder.WithSimpleSchedule(x => x
.WithInterval(TimeSpan.FromSeconds(intervalSecs))
.RepeatForever());
var trigger = builder.ForJob(RemoveOldEventsJobKey).Build();
var oldTrigger = await Scheduler.GetTrigger(RemoveOldEventsTriggerKey);
if (oldTrigger != null)
{
return(await Scheduler.RescheduleJob(RemoveOldEventsTriggerKey, trigger));
}
return(await Scheduler.ScheduleJob(trigger));
}
public static TriggerBuilder WithCronScheduleNowIfEmpty(this TriggerBuilder triggerBuilder, string cronExpression)
{
if (string.IsNullOrWhiteSpace(cronExpression))
{
return(triggerBuilder.StartNow());
}
return(triggerBuilder.WithCronSchedule(cronExpression));
}
public static TriggerBuilder Start_(this TriggerBuilder builder, DateTimeOffset?when = null)
{
var res = when == null?
builder.StartNow() :
builder.StartAt(when.Value);
return(res);
}
/// <summary>
/// 设置作业开始时间
/// </summary>
private void SetStartTime(TriggerBuilder builder, JobBase job)
{
if (job.GetStartTime() == null)
{
builder.StartNow();
return;
}
builder.StartAt(job.GetStartTime().SafeValue());
}
public void ConfigureTrigger(TriggerBuilder trigger)
{
trigger.StartNow()
.WithSimpleSchedule(schedule =>
{
schedule.RepeatForever()
.WithIntervalInHours(24)
.Build();
});
}
public static ITrigger GetTrigger()
{
//创建一个触发器
TriggerBuilder triggerBuilder = TriggerBuilder.Create();
triggerBuilder.StartNow(); //现在开始
//triggerBuilder.WithCronSchedule("/5 * * ? * *");//时间表达式
triggerBuilder.WithSimpleSchedule(x => x.WithIntervalInSeconds(5).RepeatForever()); //触发时间，5秒一次。
ITrigger jobTrigger = triggerBuilder.Build();
return(jobTrigger);
}
/// <summary>
/// 启动定时器框架-自动扫描注入启动
/// </summary>
/// <param name="app"></param>
public static void UseQuartz(this IApplicationBuilder app)
{
var serviceProvider = app.ApplicationServices;
var scheduler = serviceProvider.GetRequiredService <IScheduler>();
var jobFactory = serviceProvider.GetRequiredService <IJobFactory>();
scheduler.JobFactory = jobFactory;
// add jobdetail with trigger to scheduler
var jobs = app.ApplicationServices.GetServices <IJob>();
foreach (var job in jobs)
{
var jobDesc = job.GetType().GetCustomAttribute <JobDescriptionAttribute>();
var jobBuilder = JobBuilder.Create(job.GetType());
if (jobDesc != null)
{
jobBuilder.WithIdentity(jobDesc.Key, jobDesc.Group).WithDescription(jobDesc.Description);
}
var jobDetail = jobBuilder.Build();
ITrigger trigger;
var triggerDesc = job.GetType().GetCustomAttribute <IntervalTriggerAttribute>();
if (triggerDesc == null)
{
// default trigger
trigger = TriggerBuilder.Create().StartNow()
.WithSimpleSchedule(x => x.WithIntervalInSeconds(60).RepeatForever()).Build();
}
else
{
TriggerBuilder temp = TriggerBuilder.Create().WithIdentity(triggerDesc.Key, triggerDesc.Group).WithDescription(triggerDesc.Description);
if (triggerDesc.StartNow)
{
temp = temp.StartNow();
}
if (triggerDesc.IsRepeatForever)
{
temp = temp.WithSimpleSchedule(x => x.WithIntervalInSeconds(triggerDesc.IntervalInSeconds)
.RepeatForever());
}
else
{
temp = temp.WithSimpleSchedule(x => x.WithIntervalInSeconds(triggerDesc.IntervalInSeconds)
.WithRepeatCount(triggerDesc.RepeatCount));
}
trigger = temp.Build();
}
scheduler.ScheduleJob(jobDetail, trigger).Wait();
}
scheduler.Start().Wait();
}
static IScheduler scheduler = null;// sf.GetScheduler();
/// <summary>
///
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="jobName"></param>
/// <param name="triggerName"></param>
/// <param name="item"></param>
/// <param name="seconds">多久执行一次,</param>
/// <param name="count">执行多少次</param>
/// <param name="date"></param>
public static void JobsEx <T>(string jobName, string triggerName, KeyValuePair <string, object>?item = null,
int seconds = 1, int count = 1, DateTimeOffset?date = null)
{
#if NET40 || NET45
scheduler = sf.GetScheduler();
#else
scheduler = sf.GetScheduler().Result;
#endif
scheduler.Start();
IJobDetail detail = JobBuilder.Create(typeof(T)).WithIdentity(jobName).Build(); //new JobDetailImpl(jobName, typeof(T));
if (item.HasValue)
{
detail.JobDataMap.Add(item.Value);
}
TriggerBuilder builder = TriggerBuilder.Create().WithIdentity(triggerName); //TriggerBuilder.Create().WithIdentity(triggerName).StartAt(date.HasValue ? date.Value : DateTimeOffset.Now);
if (date.HasValue)
{
builder = builder.StartAt(date.Value);
}
else
{
builder = builder.StartNow();
}
if (count > 1)
{
if (seconds < 1)
{
seconds = 1;
}
builder = builder.WithSimpleSchedule(x => x.WithIntervalInSeconds(seconds).WithRepeatCount(count - 1));
}
else
{
builder = builder.WithSimpleSchedule();
}
ITrigger trigger = builder.Build();
scheduler.ScheduleJob(detail, trigger);
LogHelper.Info("scheduler is start " + DateTime.Now.ToStringEx());
//if (item.HasValue)
// logger.Info("scheduler param[" + JsonConvert.SerializeObject(item.Value) + "]", nameof(JobExtend));
//logger.Info("scheduler is shutdown:" + scheduler.IsShutdown);
//Console.WriteLine("scheduler is start" + DateTime.Now.ToString());
}
//WithSimpleSchedule
private static void Scheduler1()
{
try
{
Console.ReadLine();
//开启日志输出
Common.Logging.LogManager.Adapter = new Common.Logging.Simple.ConsoleOutLoggerFactoryAdapter {
Level = Common.Logging.LogLevel.Info
};
ILog log = LogManager.GetLogger(typeof(Program));
//从计划器工作实例化一个计划实例；
IScheduler scheduler = StdSchedulerFactory.GetDefaultScheduler();
//定义一个job
IJobDetail job = JobBuilder.Create <Job1>()
.WithIdentity("job1", "grop1")
.UsingJobData("jobSays", "Hello World!")
.UsingJobData("myFloatValue", 3.141f)
.Build();
//定义一个trigger
ITrigger trigger = null;
TriggerBuilder triggerBuilder = TriggerBuilder.Create();
triggerBuilder.WithIdentity("trigger1", "group1");
triggerBuilder.StartNow(); //按当前时间立即执行
triggerBuilder.WithSimpleSchedule(x => x.WithIntervalInSeconds(3).RepeatForever()); //每3秒执行，永远重复
trigger = triggerBuilder.Build();
//开始为任务做计划
DateTimeOffset dto = scheduler.ScheduleJob(job, trigger);
// 计划任务开始
scheduler.Start();
// some sleep to show what's happening
//Thread.Sleep(TimeSpan.FromSeconds(2));
// and last shut down the scheduler when you are ready to close your program
//scheduler.Shutdown();
//Console.ReadLine();
}
catch (SchedulerException se)
{
Console.WriteLine(se);
}
}
private ITrigger CreateTrigger(JobInfo jobInfo)
{
TriggerBuilder triggerBuilder = TriggerBuilder.Create().WithIdentity(jobInfo.JobName, jobInfo.JobGroup);
if (!string.IsNullOrEmpty(jobInfo.Crons))
{
//失火策略
triggerBuilder.WithCronSchedule(jobInfo.Crons);
}
triggerBuilder.StartNow();
ITrigger trigger = triggerBuilder.Build();
return(trigger);
}
public static async Task StartAsync(CronScheduleBuilder cronStart, JobDataMap data, bool startNow = false)
{
TriggerBuilder builder = TriggerBuilder.Create();
builder.WithSchedule(cronStart);
if (startNow)
{
builder.StartNow();
}
var schedulerFactory = new StdSchedulerFactory();
var scheduler = await schedulerFactory.GetScheduler();
await scheduler.Start();
await scheduler.ScheduleJob(JobBuilder.Create <ChangedTokenJob>().UsingJobData(data).Build(), builder.Build());
}
/// <summary>
/// 创建cronExpression trigger
/// </summary>
/// <param name="code">唯一编码</param>
/// <param name="group">组名</param>
/// <param name="cronExpression">周期表达式</param>
/// <param name="startNow">是否立刻启动</param>
/// <param name="timeOffset">多少时间后启动</param>
/// <returns></returns>
private static ITrigger CreateTrigger(string code, string group, string cronExpression, bool startNow, DateTimeOffset timeOffset)
{
TriggerBuilder triggerBuilder = TriggerBuilder.Create()
.WithIdentity(GetTriggerIdentityName(code), GetTriggerIdentifyGroup(group))
// 运行模式
.WithCronSchedule(cronExpression);
if (startNow)
{
triggerBuilder.StartNow();
}
else
{
if (timeOffset != null)
{
triggerBuilder.StartAt(timeOffset);
}
}
return(triggerBuilder.Build());
}
public static async void AddTaskTriggerForJob(Models.Task task, User user)
{
try
{
TriggerBuilder triggerBuilder = TriggerBuilder.Create()
.WithIdentity(task.Id.ToString())
.WithCronSchedule(task.Period);
if (DateTime.Now >= DateTime.Parse(task.StartTime))
{
triggerBuilder.StartNow();
}
else
{
triggerBuilder.StartAt(DateTimeOffset.Parse(task.StartTime));
}
ITrigger trigger = null;
if (task.ApiId == (int)APIID.COVID) // создание триггеров на задачи по получанию данных covid
{
trigger = triggerBuilder.ForJob(covidJobName).Build();
}
else if (task.ApiId == (int)APIID.FOREX) // создание триггеров на задачи по получанию данных forex
{
trigger = triggerBuilder.ForJob(forexJobName).Build();
}
else if (task.ApiId == (int)APIID.QUOTE) // создание триггеров на задачи по получанию данных quote
{
trigger = triggerBuilder.ForJob(quoteJobName).Build();
}
trigger.JobDataMap["apiParam"] = task.ApiParam;
trigger.JobDataMap["idTask"] = task.Id;
trigger.JobDataMap["userMail"] = user.Email;
await scheduler.ScheduleJob(trigger);
}
catch (Exception ex)
{
logger.Error(ex.Message);
}
}
private ITrigger CreateTrigger(ScriptAbs script)
{
TriggerBuilder triggerBuilder = TriggerBuilder
.Create()
.WithIdentity(GetTriggerKeyForScript(script));
if (script is ScriptScheduled scriptScheduled)
{
triggerBuilder
.StartAt(GetTriggerStartAt(scriptScheduled.ScheduledHour))
.WithSimpleSchedule(x => x
.WithIntervalInHours(24)
.RepeatForever()
);
}
else
{
triggerBuilder.StartNow();
}
return(triggerBuilder.Build());
}
public async Task <DateTimeOffset?> TriggerSendUnsentEventsJob(DateTime?startAt)
{
ValidateSendUnsentJobSchedule();
TriggerBuilder builder = TriggerBuilder.Create()
.WithIdentity(nameof(SendUnsentEventsJob) + Guid.NewGuid().ToString(), Constants.Group.General);
if (startAt != null)
{
builder = builder.StartAt(startAt.Value);
}
else
{
builder = builder.StartNow();
}
var trigger = builder.ForJob(SendUnsentEventsJobKey).Build();
var oldTrigger = await Scheduler.GetTrigger(SendUnsentEventsJobTriggerKey);
if (oldTrigger != null)
{
return(await Scheduler.RescheduleJob(SendUnsentEventsJobTriggerKey, trigger));
}
return(await Scheduler.ScheduleJob(trigger));
}
/// <summary>
/// 创建 Trigger
/// </summary>
/// <param name="jobInfo"></param>
/// <returns></returns>
private ITrigger CreateTrigger(JobInfo jobInfo)
{
TriggerBuilder tiggerBuilder = TriggerBuilder.Create().WithIdentity(jobInfo.JobName, jobInfo.JobGroup);
if (!string.IsNullOrWhiteSpace(jobInfo.Cron))
{
//错过的不管了，剩下的按正常执行。
//tiggerBuilder.WithCronSchedule(jobInfo.Cron, c => c.WithMisfireHandlingInstructionDoNothing());
////错过的合并为一次执行，后续正常执行。
tiggerBuilder.WithCronSchedule(jobInfo.Cron, c => c.WithMisfireHandlingInstructionFireAndProceed());
////错过的马上执行掉，后续正常执行
//tiggerBuilder.WithCronSchedule(jobInfo.Cron, c => c.WithMisfireHandlingInstructionIgnoreMisfires());
}
else
{
tiggerBuilder.WithSimpleSchedule(simple =>
{
//按正常频率执行未执行过的次数
simple.WithIntervalInSeconds(jobInfo.Second).RepeatForever().WithMisfireHandlingInstructionNextWithExistingCount();
});
}
if (jobInfo.StartTime > DateTime.Now)
{
tiggerBuilder.StartAt(jobInfo.StartTime);
}
else
{
tiggerBuilder.StartNow();
}
ITrigger trigger = tiggerBuilder.Build();
return(trigger);
}
/// <summary>
/// 执行JOB 用于检查Job_Info表
/// </summary>
/// <param name="context"></param>
public void Execute(IJobExecutionContext context)
{
Log4NetHelper.Info("开始获取JobInfo", logger: logger);
try
{
List <Job_Info> jobList = new JobInfoBLL().GetJobList();
if (jobList != null && jobList.Count > 0)
{
JobKey jobKey = null;
foreach (var jobinfo in jobList)
{
jobKey = new JobKey(jobinfo.Job_name + JobConfig.JOBKEY_NAMEEND, "group1");
//只有正常执行状态的Job才添加到调度器中
if (!JobConfig.scheduler.CheckExists(jobKey) && jobinfo.Job_state == 0)
{
IJobDetail job = JobBuilder.Create <RunTaskDLLJob>().WithIdentity(jobKey).Build();
//创建触发器
TriggerBuilder tb = TriggerBuilder.Create()
.WithIdentity(jobinfo.Job_name + JobConfig.JOBTRIGGER_NAMEEND, "group1");
if (!string.IsNullOrEmpty(jobinfo.Job_corn))
{
tb.WithCronSchedule(jobinfo.Job_corn); //执行corn表达式
}
if (jobinfo.Job_execount > 0) //如果执行固定的次数
{
tb.WithSimpleSchedule(a => a.WithRepeatCount(jobinfo.Job_execount));
}
if (jobinfo.Job_starttime != null && jobinfo.Job_starttime > DateTime.Now)//设置Job启动时间
{
tb.StartAt(jobinfo.Job_starttime);
}
else
{
tb.StartNow();
}
ITrigger trigger = tb.Build();
//传递参数
job.JobDataMap.Add(jobKey.Name, jobinfo.Id);
JobConfig.scheduler.ScheduleJob(job, trigger);
Log4NetHelper.Info(string.Format("加入Job:{0}成功", jobKey.Name), logger: logger);
}
else if (JobConfig.scheduler.CheckExists(jobKey))
{
if (jobinfo.Job_state == 2 || jobinfo.Job_state == 3)
{
JobConfig.scheduler.PauseJob(jobKey);
Log4NetHelper.Info(string.Format("暂停Job:{0}成功", jobKey.Name), logger: logger);
}
else if (jobinfo.Job_state == 4)
{
JobConfig.scheduler.DeleteJob(jobKey);
Log4NetHelper.Info(string.Format("删除Job:{0}成功", jobKey.Name), logger: logger);
}
}
}
}
}
catch (Exception ex)
{
Log4NetHelper.Info(string.Format("LoopJob异常：{0},{1},{2}", ex.Message, ex.InnerException, ex.StackTrace), logger: logger);
}
Log4NetHelper.Info("结束获取JobInfo", logger: logger);
}
public static string create_job(JOB_TYPE type, string group_name, Dictionary <string, object> para = null, string schedule = null)
{
if (para == null)
{
para = new Dictionary <string, object>()
{
}
}
;
group_name = group_name.ToLower();
string name = group_name + "." + DateTime.Now.ToString("yyMMdd-HHmmss-fff");
if (!string.IsNullOrEmpty(schedule))
{
name += "." + schedule;
}
JobDataMap m = new JobDataMap();
m.Put("ID___", name);
m.Put("SCHEDULE___", schedule);
m.Put("TYPE___", type);
m.Put("CURRENT_ID___", 0);
m.Put("COUNTER___", new ConcurrentDictionary <long, bool>());
m.Put("PARA___", para);
JobBuilder job = null;
TriggerBuilder trigger = null;
switch (type)
{
case JOB_TYPE.CRAWLER_NET:
case JOB_TYPE.CRAWLER_CURL:
job = JobBuilder.Create <JobCrawler>();
break;
case JOB_TYPE.API_JS:
job = JobBuilder.Create <JobApiJS>();
break;
}
if (job != null)
{
job = job.WithIdentity(name, group_name).UsingJobData(m);
trigger = TriggerBuilder.Create();
if (!string.IsNullOrEmpty(schedule))
{
trigger = trigger.WithSchedule(CronScheduleBuilder.CronSchedule(schedule));
}
trigger = trigger.StartNow();
var j = job.Build();
var t = trigger.Build();
m_scheduler.ScheduleJob(j, t);
m_job.TryAdd(name, j);
m_trigger.TryAdd(name, t);
m_scheduler.ScheduleJob(j, t).Wait();
return(name);
}
return(string.Empty);
}
/// <summary>
/// 初始化并启动
/// </summary>
public void Startup()
{
Task.Run(async() => {
NameValueCollection props = new NameValueCollection
{
{ "quartz.serializer.type", "binary" }
};
_factory = new StdSchedulerFactory(props);
_scheduler = await _factory.GetScheduler();
_scheduler.Context.Add("IServiceProvider", _provider);
await _scheduler.Start();
//读取数据库中所有定时任务
var tasks = await _service.GetListAsync(new Domain.Entity.System.TimedTaskSearch {
IsDeleted = false
}, null);
//加载程序集
assemblies = tasks.Select(x => x.AssemblyName).Distinct().Select(name => AssemblyLoadContext.Default.LoadFromAssemblyName(new AssemblyName(name))).ToList();
foreach (var task in tasks.Where(x => x.Status != Domain.Enum.System.EmTimedTaskStatus.Disable && x.Status != Domain.Enum.System.EmTimedTaskStatus.Expired))
{
//处理过期任务
if (task.ValidEndTime < DateTime.Now)
{
await _service.UpdateTaskStatusAsync(task.Id, new {
Status = Domain.Enum.System.EmTimedTaskStatus.Expired
});
continue;
}
var assembly = assemblies.FirstOrDefault(x => x.FullName.Split(',')[0].Equals(task.AssemblyName));
if (assembly == null)
{
//未正确加载程序集
await _service.UpdateTaskStatusAsync(task.Id, new
{
Status = Domain.Enum.System.EmTimedTaskStatus.Abnormal
});
continue;
}
var type = assembly.DefinedTypes.FirstOrDefault(x => x.FullName.Equals(task.TypeName));
if (type == null)
{
//未正确加载类型
await _service.UpdateTaskStatusAsync(task.Id, new
{
Status = Domain.Enum.System.EmTimedTaskStatus.Abnormal
});
continue;
}
// 定义一个 Job
IJobDetail job = JobBuilder.Create(type)
.WithIdentity(task.Name, task.Group)
.UsingJobData("TaskId", task.Id)
.Build();
// 定义一个触发器
TriggerBuilder builder = TriggerBuilder.Create().WithIdentity(task.Name, task.Group);
if (task.ValidStartTime <= DateTime.Now)
{
builder = builder.StartNow();
}
else
{
builder = builder.StartAt(task.ValidStartTime);
}
builder = builder.EndAt(task.ValidEndTime);
//Cron
builder = builder.WithCronSchedule(task.Cron);
ITrigger trigger = builder.Build();
//加入Job
await _scheduler.ScheduleJob(job, trigger);
}
});
}
