static void Main(string[] args)
{
Console.WriteLine(DateTime.Now.ToString("r"));
//1.首先创建一个作业调度池
ISchedulerFactory schedf = new StdSchedulerFactory();
IScheduler sched = schedf.GetScheduler();
//2.创建出来一个具体的作业
IJobDetail job = JobBuilder.Create <JobDemo>().Build();
//NextGivenSecondDate：如果第一个参数为null则表名当前时间往后推迟2秒的时间点。
DateTimeOffset startTime = DateBuilder.NextGivenSecondDate(DateTime.Now.AddSeconds(1), 2);
DateTimeOffset endTime = DateBuilder.NextGivenSecondDate(DateTime.Now.AddHours(2), 3);
//3.创建并配置一个触发器
//ISimpleTrigger trigger = (ISimpleTrigger)TriggerBuilder.Create().WithSimpleSchedule(x => x.WithIntervalInSeconds(3).WithRepeatCount(int.MaxValue)).Build();
//ISimpleTrigger trigger = (ISimpleTrigger)TriggerBuilder.Create().StartAt(startTime).EndAt(endTime)
// .WithSimpleSchedule(x => x.WithIntervalInSeconds(3).WithRepeatCount(100))
// .Build();
ICronTrigger trigger = (ICronTrigger)TriggerBuilder.Create().StartAt(startTime).EndAt(endTime)
.WithCronSchedule("1,10,14 10,20,25,26,33,54 * * * ? ")
.Build();
//4.加入作业调度池中
sched.ScheduleJob(job, trigger);
//5.开始运行
sched.Start();
Console.ReadKey();
//Add some comments.
}
/// <summary>
/// 添加任务计划
/// </summary>
/// <returns></returns>
private async Task AddScheduleJob(List <OpenJobEntity> entityList)
{
try
{
foreach (OpenJobEntity entity in entityList)
{
entity.F_StarRunTime = DateTime.Now;
entity.F_EndRunTime = DateTime.Now.AddSeconds(-1);
DateTimeOffset starRunTime = DateBuilder.NextGivenSecondDate(entity.F_StarRunTime, 1);
DateTimeOffset endRunTime = DateBuilder.NextGivenSecondDate(DateTime.MaxValue.AddDays(-1), 1);
await _service.SubmitForm(entity, entity.F_Id);
IJobDetail job = JobBuilder.Create <JobExecute>().WithIdentity(entity.F_JobName, entity.F_JobGroup).Build();
job.JobDataMap.Add("F_Id", entity.F_Id);
ICronTrigger trigger = (ICronTrigger)TriggerBuilder.Create()
.StartAt(starRunTime)
.EndAt(endRunTime)
.WithIdentity(entity.F_JobName, entity.F_JobGroup)
.WithCronSchedule(entity.F_CronExpress)
.Build();
await _scheduler.ScheduleJob(job, trigger);
}
}
catch (Exception ex)
{
LogHelper.WriteWithTime(ex);
}
}
private static void CodeMethod()
{
Console.WriteLine(DateTime.Now.ToString());
//1.首先创建一个作业调度池
ISchedulerFactory schedulerFactory = new StdSchedulerFactory();
var scheduler = schedulerFactory.GetScheduler();
//2.创建出来一个具体的作业
IJobDetail job = JobBuilder.Create <JobDemo>().Build();
//3.创建并配置一个触发器
#region 每隔5秒执行一次Execute方法，无休止
//ISimpleTrigger trigger = (ISimpleTrigger)TriggerBuilder.Create().WithSimpleSchedule(x => x.WithIntervalInSeconds(5).WithRepeatCount(int.MaxValue)).Build();
#endregion
#region 序每5秒执行一次，一共执行50次，开始执行时间设定在当前时间，结束时间我设定在1小时后，不管50次有没有执行完，1小时后，程序都不再继续执行
DateTimeOffset startTime = DateBuilder.NextGivenSecondDate(DateTime.Now.AddSeconds(1), 2);
DateTimeOffset endTime = DateBuilder.NextGivenSecondDate(DateTime.Now.AddHours(1), 5);
//ISimpleTrigger trigger = (ISimpleTrigger)TriggerBuilder.Create().StartAt(startTime).EndAt(endTime)
// .WithSimpleSchedule(x => x.WithIntervalInSeconds(5).WithRepeatCount(50))
// .Build();
#endregion
#region 实现各种时间纬度的调用（使用cron-like）：在每小时的第10，20，30分钟，每分钟的第11，27秒执行一次
ICronTrigger trigger = (ICronTrigger)TriggerBuilder.Create().StartAt(startTime).EndAt(endTime).WithCronSchedule("11,27 10,20,30 * * * ? ").Build();
#endregion
//4.加入作业调度池中
scheduler.ScheduleJob(job, trigger);
//5.开始运行
scheduler.Start();
Console.ReadKey();
}
public static async void CreateJobRepeat <T>(string cron, int repeatCount, Dictionary <string, object> keyValues = default, DateTimeOffset startAt = default) where T : IJob
{
var name = NewToken();
var group = NewToken();
var job = JobBuilder.Create <T>()
.WithIdentity(name, group)
.Build();
if (keyValues != default)
{
foreach (var item in keyValues)
{
job.JobDataMap[item.Key] = item.Value;
}
}
if (startAt == null)
{
startAt = DateBuilder.NextGivenSecondDate(DateTime.Now, 1);
}
var cronTrigger = TriggerBuilder.Create()
.StartAt(startAt)
.WithIdentity(name + "Trigger", group + "Trigger")
.WithCronSchedule(cron)
.WithSchedule(SimpleScheduleBuilder.RepeatMinutelyForTotalCount(repeatCount))
.Build();
await scheduler.ScheduleJob(job, cronTrigger);
}
public static IScheduler GetSchedulers(IScheduler sched)
{
DateTimeOffset startTime = DateBuilder.NextGivenSecondDate(null, 10);
UnityContainer container = new UnityContainer();
container.RegisterType <ISiteBLL, SiteBLL>();
//返回调用者
ISiteBLL ISite = container.Resolve <SiteBLL>();
List <JobSite> sites = ISite.getJobSites();
_logger.InfoFormat("任务初始化共" + sites.Count + "个站点");
foreach (JobSite s in sites)
{
IJobDetail job = JobBuilder.Create <GT.SiteCheck.Job.SiteCheckJob>().WithIdentity(s.site.name, s.node.nodeName).Build();
ISimpleTrigger trigger = (ISimpleTrigger)TriggerBuilder.Create()
.WithIdentity(s.site.name, s.node.nodeName)
.StartAt(startTime)
.WithSimpleSchedule(x => x.WithIntervalInSeconds(s.site.interval.Value).RepeatForever()) //.WithRepeatCount(2)
.Build();
job.JobDataMap.Put(GT.SiteCheck.Job.SiteCheckJob.site, s.site);
sched.ScheduleJob(job, trigger);
}
return(sched);
}
public virtual void Run()
{
log.Info("------- Initializing ----------------------");
// First we must get a reference to a scheduler
ISchedulerFactory sf = new StdSchedulerFactory();
IScheduler sched = sf.GetScheduler();
log.Info("------- Initialization Complete -----------");
log.Info("------- Scheduling Jobs -------------------");
// get a "nice round" time a few seconds in the future...
DateTimeOffset startTime = DateBuilder.NextGivenSecondDate(null, 15);
IJobDetail job = JobBuilder.Create <DumbInterruptableJob>()
.WithIdentity("interruptableJob1", "group1")
.Build();
ISimpleTrigger trigger = (ISimpleTrigger)TriggerBuilder.Create()
.WithIdentity("trigger1", "group1")
.StartAt(startTime)
.WithSimpleSchedule(x => x.WithIntervalInSeconds(5).RepeatForever())
.Build();
DateTimeOffset ft = sched.ScheduleJob(job, trigger);
log.Info(string.Format("{0} will run at: {1} and repeat: {2} times, every {3} seconds", job.Key, ft.ToString("r"), trigger.RepeatCount, trigger.RepeatInterval.TotalSeconds));
// start up the scheduler (jobs do not start to fire until
// the scheduler has been started)
sched.Start();
log.Info("------- Started Scheduler -----------------");
log.Info("------- Starting loop to interrupt job every 7 seconds ----------");
for (int i = 0; i < 50; i++)
{
try
{
Thread.Sleep(TimeSpan.FromSeconds(7));
// tell the scheduler to interrupt our job
sched.Interrupt(job.Key);
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
}
log.Info("------- Shutting Down ---------------------");
sched.Shutdown(true);
log.Info("------- Shutdown Complete -----------------");
SchedulerMetaData metaData = sched.GetMetaData();
log.Info(string.Format("Executed {0} jobs.", metaData.NumberOfJobsExecuted));
}
private async Task AddCheckNotCompletedJobAsync <TServiceJobName>()
where TServiceJobName : ServiceJob, new()
{
Dictionary <string, object> jobDataMap = new Dictionary <string, object>
{
["jobCallTypes"] = JobCallTypes.CheckNotCompleted
};
IJobDetail job = JobBuilder.Create <TServiceJobName>()
.WithIdentity(typeof(TServiceJobName).Name + "_chk")
.Build();
job.JobDataMap.PutAll(jobDataMap);
var serviceJob = new TServiceJobName();
DateTimeOffset startTime = DateBuilder.NextGivenSecondDate(null, 5);
var schedulePattern = dataSyncConfiguration.SchedulePattern.CheckFailureMode;
if (string.IsNullOrWhiteSpace(dataSyncConfiguration.Services[serviceJob.serviceName].AcquireSchedulePattern) == false)
{
schedulePattern = dataSyncConfiguration.Services[serviceJob.serviceName].AcquireSchedulePattern;
}
ITrigger trigger = TriggerBuilder.Create()
.WithIdentity("trigger_chk_" + typeof(TServiceJobName).Name + "_")
.StartAt(startTime)
.WithCronSchedule(dataSyncConfiguration.SchedulePattern.CheckFailureMode)
.ForJob(job)
.Build();
await mainScheduler.ScheduleJob(job, trigger);
}
async Task <bool> IJobCenter.AddScheduleJobAsync(JobCenterOptions options, Type jobType)
{
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
DateTimeOffset starRunTime = DateBuilder.NextGivenSecondDate(options.StarRunTime, 1);
DateTimeOffset endRunTime = DateBuilder.NextGivenSecondDate(options.EndRunTime, 1);
IScheduler scheduler = await _SchedulerFactory.GetScheduler();
IJobDetail job = JobBuilder.Create(jobType)
.WithIdentity(options.JobName, options.JobGroup)
.Build();
ICronTrigger trigger = (ICronTrigger)TriggerBuilder.Create()
.StartAt(starRunTime)
.EndAt(endRunTime)
.WithIdentity(options.JobName, options.JobGroup)
.WithCronSchedule(options.CromExpress)
.Build();
await scheduler.ScheduleJob(job, trigger);
await scheduler.Start();
return(true);
}
private static void CodeMethod()
{
Console.WriteLine(DateTime.Now.ToString());
//1.创建一个作业调度池
ISchedulerFactory scheduler = new StdSchedulerFactory();
IScheduler sched = scheduler.GetScheduler();
//2.创建一个具体的作业
IJobDetail job = JobBuilder.Create <JobDemo>().Build();
//3.创建并配置一个触发器
#region 每隔5秒执行一次Execute方法，无休止
//ISimpleTrigger trigger=(ISimpleTrigger)TriggerBuilder.Create().WithSimpleSchedule(x => x.WithIntervalInSeconds(5).WithRepeatCount(int.MaxValue)).Build();
#endregion
DateTimeOffset startTime = DateBuilder.NextGivenSecondDate(DateTime.Now.AddSeconds(1), 2);
DateTimeOffset endTime = DateBuilder.NextGivenSecondDate(DateTime.Now.AddHours(1), 5);
#region 每隔5秒执行一次，一共执行50次，开始时间设定在当前时间，结束时间设定在1小时后，不管50次有没有执行完，1小时候程序都不在继续执行
ISimpleTrigger trigger = (ISimpleTrigger)TriggerBuilder.Create().StartAt(startTime).EndAt(endTime).WithSimpleSchedule(x => x.WithIntervalInSeconds(5).WithRepeatCount(50)).Build();
#endregion
#region 使用cron-like维度调用
//ICronTrigger trigger = (ICronTrigger)TriggerBuilder.Create().StartAt(startTime).EndAt(endTime).WithCronSchedule("11,27 10,20,30 * * * ? ").Build();
#endregion
//4.加入作业调度池中
sched.ScheduleJob(job, trigger);
sched.Start();
Console.ReadKey();
}
/// <summary>
/// 添加任务计划//或者进程终止后的开启
/// </summary>
/// <returns></returns>
public static async Task <bool> StartScheduleJobAsync(ScheduleInfo scheduleInfo, bool doatonce)
{
try
{
if (scheduleInfo != null)
{
if (scheduleInfo.StartRunTime == null)
{
scheduleInfo.StartRunTime = DateTime.Now;
}
DateTimeOffset startRunTime = DateBuilder.NextGivenSecondDate(scheduleInfo.StartRunTime, 1);
if (scheduleInfo.EndRunTime == null)
{
scheduleInfo.EndRunTime = DateTime.MaxValue.AddDays(-1);
}
DateTimeOffset endRunTime = DateBuilder.NextGivenSecondDate(scheduleInfo.EndRunTime, 1);
if (string.IsNullOrWhiteSpace(scheduleInfo.CronExpress) || doatonce)
{
DateTime dt = DateTime.Now.AddMinutes(1);
scheduleInfo.CronExpress = $"0 {dt.Minute} {dt.Hour} * * ?";
}
_scheduler = await GetSchedulerAsync();
Type type = Type.GetType(scheduleInfo.JobName, true, true);
IJobDetail job = JobBuilder.Create(type)
.WithIdentity(scheduleInfo.JobName, scheduleInfo.JobGroup)
.Build();
ICronTrigger trigger = (ICronTrigger)TriggerBuilder.Create()
.StartAt(startRunTime)
.EndAt(endRunTime)
.WithIdentity(scheduleInfo.JobName, scheduleInfo.JobGroup)
.WithCronSchedule(scheduleInfo.CronExpress)
.Build();
((CronTriggerImpl)trigger).MisfireInstruction = MisfireInstruction.CronTrigger.DoNothing;
//将信息写入
scheduleInfo.RunStatus = (int)JobStatus.Waiting;
Manager.SaveSchedule(scheduleInfo);
IList <ICronTrigger> triggers = new List <ICronTrigger> {
trigger
};
await _scheduler.ScheduleJob(job, new ReadOnlyCollection <ICronTrigger>(triggers), true);
if (!_scheduler.IsStarted)
{
await _scheduler.Start();
}
return(true);
}
return(false);
}
catch (Exception ex)
{
if (ex.Message.Contains("because one already exists with this identification"))
{
string ret = await ResumeScheduleJobAsync(scheduleInfo);
}
return(false);
}
}
private static void Example1()
{
Console.WriteLine(DateTime.Now.ToString("r"));
//1.首先创建一个作业调度池
ISchedulerFactory schedf = new StdSchedulerFactory();
IScheduler sched = schedf.GetScheduler().Result;
//2.创建出来一个具体的作业
IJobDetail job = JobBuilder.Create <JobDemo>().Build();
//3.创建并配置一个触发器
//ISimpleTrigger trigger = (ISimpleTrigger)TriggerBuilder.Create().WithSimpleSchedule(x => x.WithIntervalInSeconds(3).WithRepeatCount(3)).Build();
//NextGivenSecondDate：如果第一个参数为null则表名当前时间往后推迟2秒的时间点。
//使用2：假如没执行完1分钟后不执行
DateTimeOffset startTime = DateBuilder.NextGivenSecondDate(DateTime.Now.AddSeconds(1), 2);
//DateTimeOffset endTime = DateBuilder.NextGivenSecondDate(DateTime.Now.AddMinutes(1), 3);
//ISimpleTrigger trigger = (ISimpleTrigger)TriggerBuilder.Create().StartAt(startTime).EndAt(endTime).
// WithSimpleSchedule(x => x.WithIntervalInSeconds(3).WithRepeatCount(100)).Build();
//使用3：每分钟的第1,10,14,25,35,50秒执行一次。
//那么上面显然是不能满足的。这是我就把cron-like（由7段构成：秒 分 时 日 月 星期 年（可选））表达式引入进来，以实现各种时间纬度的调用
//"-" ：表示范围 MON-WED表示星期一到星期三
// "," ：表示列举 MON, WEB表示星期一和星期三
//"*" ：表是“每”，每月，每天，每周，每年等
//"/" :表示增量：0 / 15（处于分钟段里面） 每15分钟，在0分以后开始，3 / 20 每20分钟，从3分钟以后开始
//"?" :只能出现在日，星期段里面，表示不指定具体的值
//"L" :只能出现在日，星期段里面，是Last的缩写，一个月的最后一天，一个星期的最后一天（星期六）
//"W" :表示工作日，距离给定值最近的工作日
//"#" :表示一个月的第几个星期几，例如："6#3"表示每个月的第三个星期五（1 = SUN...6 = FRI,7 = SAT）
DateTimeOffset endTime = DateBuilder.NextGivenSecondDate(DateTime.Now.AddYears(2), 3);
ICronTrigger trigger = (ICronTrigger)TriggerBuilder.Create().StartAt(startTime).EndAt(endTime)
.WithCronSchedule("1,10,14,25,35,50 * * * * ? ")
.Build();
//4.加入作业调度池中
sched.ScheduleJob(job, trigger);
//加入第二个作业 1个job只能绑定在1个trigger
IJobDetail job2 = JobBuilder.Create <JobDemo2>().WithIdentity("job2", "gorup2").Build();
ISimpleTrigger trigger2 = (ISimpleTrigger)TriggerBuilder.Create().
WithSimpleSchedule(x => x.WithIntervalInSeconds(3).WithRepeatCount(2)).Build();
sched.ScheduleJob(job2, trigger2);
//5.开始运行
sched.Start();
////挂起3分钟
//Thread.Sleep(TimeSpan.FromMinutes(3));
////3分钟后关闭作业调度，将不在执行
//sched.Shutdown();
//暂停所有
//sched.PauseAll();
//1分钟后移除trigger2
Thread.Sleep(TimeSpan.FromMinutes(1));
//重启
//sched.ResumeAll();
sched.UnscheduleJob(trigger2.Key);//移除trigger2
}
/// <summary>
/// 添加任务计划//或者进程终止后的开启
/// </summary>
/// <returns></returns>
public static async Task <bool> StartScheduleJobAsync(Diary info)
{
try
{
if (info != null)
{
if (info.RunningStart == null)
{
info.RunningStart = DateTime.Now;
}
DateTimeOffset startRunTime = DateBuilder.NextGivenSecondDate(info.RunningStart, 1);
if (info.RunningEnd == null)
{
info.RunningEnd = DateTime.MaxValue.AddDays(-1);
}
DateTimeOffset endRunTime = DateBuilder.NextGivenSecondDate(info.RunningEnd, 1);
if (string.IsNullOrWhiteSpace(info.CronExpress))
{
DateTime dt = DateTime.Now.AddMinutes(1);
info.CronExpress = $"0 {dt.Minute} {dt.Hour} * * ?";
}
_scheduler = await GetSchedulerAsync();
Type type = typeof(RemindJob); // Type.GetType(info.JobName, true, true);
IJobDetail job = JobBuilder.Create(type)
.WithIdentity(info.JobName, info.JobGroup)
.Build();
job.JobDataMap.Put(Common.REMIND_CONTENT, $"【主题】{info.Title}\r\n【内容】{info.Content}");
ICronTrigger trigger = (ICronTrigger)TriggerBuilder.Create()
.StartAt(startRunTime)
.EndAt(endRunTime)
.WithIdentity(info.JobName, info.JobGroup)
.WithCronSchedule(info.CronExpress)
.Build();
((CronTriggerImpl)trigger).MisfireInstruction = MisfireInstruction.CronTrigger.DoNothing;
IList <ICronTrigger> triggers = new List <ICronTrigger> {
trigger
};
await _scheduler.ScheduleJob(job, new ReadOnlyCollection <ICronTrigger>(triggers), true);
if (!_scheduler.IsStarted)
{
await _scheduler.Start();
}
return(true);
}
return(false);
}
catch (Exception ex)
{
if (ex.Message.Contains("because one already exists with this identification"))
{
_ = await ResumeScheduleJobAsync(info);
}
return(false);
}
}
public void NextGivenSecondDateShouldWork()
{
DateTimeOffset dto = new DateTimeOffset(new DateTime(2011, 11, 14, 21, 59, 0));
var nextGivenSecondDate = DateBuilder.NextGivenSecondDate(dto, 0);
Assert.AreEqual(22, nextGivenSecondDate.Hour);
Assert.AreEqual(0, nextGivenSecondDate.Minute);
Assert.AreEqual(0, nextGivenSecondDate.Second);
}
/// <summary>
/// 添加调度任务
/// </summary>
/// <param name="JobName">任务名称</param>
/// <param name="JobGroup">任务分组</param>
/// <param name="JobNamespaceAndClassName">任务完全限定名</param>
/// <param name="JobAssemblyName">任务程序集名称</param>
/// <param name="CronExpress">Cron表达式</param>
/// <param name="StarTime">开始时间</param>
/// <param name="EndTime">结束时间</param>
/// <returns></returns>
public async Task <ScheduleResult> AddJobAsync(String JobName, String JobGroup, String JobNamespaceAndClassName, String JobAssemblyName, string CronExpress)
{
ScheduleResult result = new ScheduleResult();
try
{
if (string.IsNullOrEmpty(JobName) || string.IsNullOrEmpty(JobGroup) || string.IsNullOrEmpty(JobNamespaceAndClassName) || string.IsNullOrEmpty(JobAssemblyName) || string.IsNullOrEmpty(CronExpress))
{
result.ResultCode = -3;
result.ResultMsg = $"参数不能为空";
return(result);//出现异常
}
var starRunTime = DateTime.Now;
var EndTime = DateTime.MaxValue.AddDays(-1);
DateTimeOffset endRunTime = DateBuilder.NextGivenSecondDate(EndTime, 1);
JobKey jobKey = new JobKey(JobName, JobGroup);
if (await Scheduler.CheckExists(jobKey))
{
await Scheduler.PauseJob(jobKey);
await Scheduler.DeleteJob(jobKey);
}
Assembly assembly = Assembly.LoadFile(JobAssemblyName);
Type jobType = assembly.GetType(JobNamespaceAndClassName);
//var jobType = Type.GetType(JobNamespaceAndClassName + "," + JobAssemblyName);
if (jobType == null)
{
result.ResultCode = -1;
result.ResultMsg = "系统找不到对应的任务，请重新设置";
return(result);//出现异常
}
IJobDetail job = JobBuilder.Create(jobType)
.WithIdentity(jobKey).UsingJobData("ServerName", Scheduler.SchedulerName)
.Build();
ICronTrigger trigger = (ICronTrigger)TriggerBuilder.Create()
.StartAt(starRunTime)
.EndAt(endRunTime)
.WithIdentity(JobName, JobGroup)
.WithCronSchedule(CronExpress)
.Build();
await Scheduler.ScheduleJob(job, trigger);
if (!Scheduler.IsStarted)
{
await Scheduler.Start();
}
return(result);
}
catch (Exception ex)
{
_logger.LogError(ex, nameof(AddJobAsync));
result.ResultCode = -4;
result.ResultMsg = ex.ToString();
return(result);//出现异常
}
}
//public int minutos = 40;
static public bool StarWatchDog()
{
// construct a scheduler factory
ISchedulerFactory schedFact = new StdSchedulerFactory();
// get a scheduler
IScheduler sched = schedFact.GetScheduler();
// jobs can be scheduled before sched.start() has been called
// get a "nice round" time a few seconds in the future...
DateTimeOffset startTime = DateBuilder.NextGivenSecondDate(null, 30);
// job1 will only fire once at date/time "ts"
IJobDetail job = JobBuilder.Create <TaskVariable>()
.WithIdentity("job1", "group1")
.Build();
ISimpleTrigger trigger = (ISimpleTrigger)TriggerBuilder.Create()
.WithIdentity("trigger1", "group1")
.StartAt(startTime)
.WithSimpleSchedule(x => x.WithIntervalInMinutes(2).RepeatForever())
//.ForJob(job)
.Build();
// schedule it to run!
DateTimeOffset?ft = sched.ScheduleJob(job, trigger);
IJobDetail job2 = JobBuilder.Create <TaskQuorum>()
.WithIdentity("job2", "group1")
.Build();
ISimpleTrigger trigger2 = (ISimpleTrigger)TriggerBuilder.Create()
.WithIdentity("trigger2", "group1")
.StartAt(startTime)
.WithSimpleSchedule(x => x.WithIntervalInMinutes(3).RepeatForever())
//.ForJob(job)
.Build();
ft = sched.ScheduleJob(job2, trigger2);
// schedule it to run!
sched.Start();
return(true);
}
//我想让他每三秒执行一次，一共执行100次，开始执行时间设定在当前时间，结束时间我设定在2小时后，不过100次执行完没2小时候都不再执行
public static ISimpleTrigger EndTaskWhenHours()
{
//NextGivenSecondDate：如果第一个参数为null则表名当前时间往后推迟2秒的时间点。
DateTimeOffset startTime = DateBuilder.NextGivenSecondDate(DateTime.Now.AddSeconds(1), 2);
DateTimeOffset endTime = DateBuilder.NextGivenSecondDate(DateTime.Now.AddHours(2), 3);
//创建并配置一个触发器
ISimpleTrigger trigger = (ISimpleTrigger)TriggerBuilder.Create().StartAt(startTime).EndAt(endTime)
.WithSimpleSchedule(x => x.WithIntervalInSeconds(3).WithRepeatCount(100))
.Build();
return(trigger);
}
public bool RunAtOnce(string jobName, string jobGroupName)
{
try
{
JobKey jobKey = CreateJobKey(jobName, jobGroupName);
JobDataModel jobData = Xml.XmlJobManage.GetJobDataByKey(jobKey);
if (jobData == null)
{
return(false);
}
JobKey jobKeyOnce = CreateJobKey(jobName, JobConfig.JobGroupNameOnce);
var type = typeof(HttpJob);
if (jobData.JobType == JobType.Assembly)
{
string path = System.IO.Path.Combine(AppDomain.CurrentDomain.BaseDirectory, jobData.AssemblyDllName);
Assembly assembly = Assembly.LoadFile(path);
type = assembly.GetType(jobData.TypeFullName);
}
var bl = _scheduler.CheckExists(jobKeyOnce).GetAwaiter().GetResult();
if (bl)
{
_scheduler.DeleteJob(jobKeyOnce);
}
IJobDetail jobDetail = JobBuilder.Create(type)
.WithIdentity(jobKeyOnce)
.UsingJobData(JobConfig.CallbackUrl, jobData.CallbackUrl)
.UsingJobData(JobConfig.CallbackParams, JobUtils.GetDictToString(jobData.CallbackParams))
.Build();
DateTimeOffset startTime = DateBuilder.NextGivenSecondDate(null, 2);
ITrigger trigger = TriggerBuilder.Create()
.WithIdentity(JobConfig.GetTriggerNameOnce(jobName), JobConfig.TriggerGroupNameOnce)
.StartAt(startTime)
.Build();
_scheduler.ScheduleJob(jobDetail, trigger).GetAwaiter().GetResult();
return(true);
}
catch (Exception ex)
{
logger.Error(ex);
}
return(false);
}
/// <summary>
/// 创建类型Cron的触发器
/// </summary>
/// <param name="m"></param>
/// <returns></returns>
private static ITrigger CreateCronTrigger(TasksQz tasksQz)
{
DateTimeOffset starRunTime = DateBuilder.NextGivenSecondDate(tasksQz.StartTime ?? DateTime.Now, 1);
DateTimeOffset endRunTime = DateBuilder.NextGivenSecondDate(tasksQz.EndTime ?? DateTime.MaxValue.AddDays(-1), 1);
// 作业触发器
return(TriggerBuilder.Create()
.WithIdentity(tasksQz.Id.ToString(), tasksQz.JobGroup)
.StartAt(starRunTime) //开始时间
.EndAt(endRunTime) //结束数据
.WithCronSchedule(tasksQz.Cron) //指定cron表达式
.ForJob(tasksQz.Id.ToString(), tasksQz.JobGroup) //作业名称
.Build());
}
/// <summary>
/// 添加多触发器任务
/// </summary>
/// <param name="jobName">任务名称</param>
/// <param name="jobGroupName">任务组名称</param>
/// <param name="starTime">开始时间</param>
/// <param name="endTime">结束时间</param>
/// <param name="keyValue">任务主键</param>
/// <param name="list">cron数组</param>
public static void AddListCronJob(string jobName, string starTime, string endTime, string keyValue, List <string> list)
{
try
{
IScheduler sched = schedFact.GetScheduler(); //得到一个调度程序
IJobDetail job = JobBuilder.Create <SchedulingHelper>() //新建任务执行类
.WithIdentity(jobName, "lrts") // name "myJob", group "group1"
.UsingJobData("keyValue", keyValue) //传递参数
.StoreDurably()
.Build();
///开始时间处理
DateTime StarTime = DateTime.Now;
if (!string.IsNullOrEmpty(starTime))
{
StarTime = Convert.ToDateTime(starTime);
}
DateTimeOffset starRunTime = DateBuilder.NextGivenSecondDate(StarTime, 1);
///结束时间处理
DateTime EndTime = DateTime.MaxValue.AddDays(-1);
if (!string.IsNullOrEmpty(endTime))
{
EndTime = Convert.ToDateTime(endTime);
}
DateTimeOffset endRunTime = DateBuilder.NextGivenSecondDate(EndTime, 1);
sched.AddJob(job, true);
// 创建一个时间触发器
for (var i = 0; i < list.Count; i++)
{
ITrigger trigger = TriggerBuilder.Create()
.WithIdentity("trigger" + Guid.NewGuid().ToString())
.StartAt(starRunTime)
.EndAt(endRunTime)
.ForJob(job)
.WithCronSchedule(list[i])
.Build();
sched.ScheduleJob(trigger);
}
// 启动
if (!sched.IsStarted)
{
sched.Start();
}
}
catch (Exception e)
{
throw (e);
}
}
/// <summary>
/// 添加调度任务
/// </summary>
/// <param name="jobName">任务名称</param>
/// <param name="jobGroup">任务分组</param>
/// <returns></returns>
public async Task <bool> AddJobAsync(CreateUpdateJobInfoDto infoDto)
{
try
{
if (infoDto != null)
{
if (infoDto.StarTime == null)
{
infoDto.StarTime = DateTime.Now;
}
DateTimeOffset starRunTime = DateBuilder.NextGivenSecondDate(infoDto.StarTime, 1);
if (infoDto.EndTime == null)
{
infoDto.EndTime = DateTime.MaxValue.AddDays(-1);
}
DateTimeOffset endRunTime = DateBuilder.NextGivenSecondDate(infoDto.EndTime, 1);
scheduler = await GetSchedulerAsync();
JobKey jobKey = new JobKey(infoDto.JobName, infoDto.JobGroup);
if (await scheduler.CheckExists(jobKey))
{
await scheduler.PauseJob(jobKey);
await scheduler.DeleteJob(jobKey);
}
IJobDetail job = JobBuilder.Create <LogTestJob>()
.WithIdentity(jobKey)
.Build();
ICronTrigger trigger = (ICronTrigger)TriggerBuilder.Create()
.StartAt(starRunTime)
.EndAt(endRunTime)
.WithIdentity(infoDto.JobName, infoDto.JobGroup)
.WithCronSchedule(infoDto.CronExpress)
.Build();
await scheduler.ScheduleJob(job, trigger);
await scheduler.Start();
return(true);
}
return(false);//JobInfo为空
}
catch (Exception ex)
{
_logger.LogException(ex);
return(false);//出现异常
}
}
public static async Task <bool> AddJob(QuartzModel model)
{
var IsSuccess = false;
var sche = await GetScheduler();
model.SchedName = sche.SchedulerName;
//验证是否是正确的Cron表达式
if (CronExpression.IsValidExpression(model.TriggerCron))
{
JobKey jk = new JobKey(model.JobName, model.JobGroup);
//var scheduRes = sche.Result;
var IsExist = sche.CheckExists(jk).GetAwaiter().GetResult();
if (IsExist)
{
LogHelper.WriteError($"Job:{model.JobName}已存在", new Exception($"Job:{model.JobName}已存在"));
//throw new Exception($"Job:{model.JobName}已存在");
return(false);
}
var type = GetClassInfo(model.JobClassName);
if (type != null)
{
if (model.StarRunTime == null)
{
model.StarRunTime = DateTime.Now;
}
DateTimeOffset starRunTime = DateBuilder.NextGivenSecondDate(model.StarRunTime, 1);
if (model.EndRunTime == null)
{
model.EndRunTime = DateTime.MaxValue.AddDays(-1);
}
DateTimeOffset endRunTime = DateBuilder.NextGivenSecondDate(model.EndRunTime, 1);
IJobDetail job = new JobDetailImpl(model.JobName, model.JobGroup, type);
ICronTrigger trigger = (ICronTrigger)TriggerBuilder.Create()
.StartAt(starRunTime)
.EndAt(endRunTime)
.WithDescription(model.Description)
.WithIdentity(model.JobName, model.JobGroup)
.WithCronSchedule(model.TriggerCron)
.Build();
sche.ScheduleJob(job, trigger).GetAwaiter().GetResult();
LogHelper.WriteInfo($"Job:{model.JobName}添加完成");
IsSuccess = true;
}
}
return(IsSuccess);
}
/// <summary>
/// 创建只触发一次的触发器
/// </summary>
/// <param name="secondBase">时间</param>
/// <param name="forJob">此触发器将关联到哪一个作业</param>
/// <returns></returns>
public static ISimpleTrigger CreateOnceTrigger(int secondBase, IJobDetail forJob = null)
{
DateTimeOffset startTime = DateBuilder.NextGivenSecondDate(null, secondBase);
TriggerBuilder builder =
TriggerBuilder.Create()
.WithIdentity(System.Guid.NewGuid().ToString())
.WithDescription("此触发器只执行一次.")
.StartAt(startTime);
if (forJob != null)
{
builder = builder.ForJob(forJob);
}
return((ISimpleTrigger)builder.Build());
}
protected override ITrigger CreateTrigger(string name)
{
DateTimeOffset startTime = DateBuilder.NextGivenSecondDate(null, 5);
/*
* Seconds Minutes Hours Day-of-Month Month Day-of-Week Year (optional field)
* the value “L” in the day-of-month field means “the last day of the month” - day 31 for January,
* day 28 for February on non-leap years
*/
return(TriggerBuilder.Create()
.WithIdentity(name, "serviceGroups")
//.WithCronSchedule("0 30 0 * * ?")
.StartAt(startTime)
.Build());
}
/// <summary>
/// 添加一个工作调度（映射程序集指定IJob实现类）
/// </summary>
/// <returns></returns>
private void AddScheduleJobAsync(TaskScheduleModel m)
{
if (!IsStart)
{
throw new Exception("任务计划未初始化");
}
//检查任务是否已存在
var jk = new JobKey(m.JobName, m.JobGroup);
if (scheduler.CheckExists(jk).Result)
{
//删除已经存在任务
scheduler.PauseJob(jk).Wait(); //先暂停
scheduler.DeleteJob(jk).Wait(); //在删除
Logger.LogInformation($"移除了老任务{m.JobGroup}.{m.JobName}");
}
DateTimeOffset starRunTime = DateBuilder.NextGivenSecondDate(m.StarRunTime, 1);
DateTimeOffset endRunTime = DateBuilder.NextGivenSecondDate(m.EndRunTime, 1);
//反射获取IJob实现
string dllFilePath = Path.Combine(WebHostEnvironment.WebRootPath, "JobPlugins") + "/" + m.FileName;
Assembly assembly = Assembly.LoadFile(dllFilePath);
Type[] types = assembly.GetExportedTypes();
Type typeIJob = typeof(IJob);
Type jobType = null;
for (int i = 0; i < types.Length; i++)
{
if (typeIJob.IsAssignableFrom(types[i]) && !types[i].IsAbstract)
{
jobType = types[i];
break;
}
}
IJobDetail job = JobBuilder.Create(jobType)
.WithIdentity(m.JobName, m.JobGroup)
.Build();
ICronTrigger trigger = (ICronTrigger)TriggerBuilder.Create()
.StartAt(starRunTime)
.EndAt(endRunTime)
.WithIdentity(m.JobName, m.JobGroup)
.WithCronSchedule(m.CronExpress)
.Build();
scheduler.ScheduleJob(job, trigger).Wait();
Logger.LogInformation($"创建新任务{m.JobGroup}.{m.JobName}");
}
private async Task <bool> StartScheduleJobAsync(ScheduleInfo scheduleInfo)
{
try
{
if (scheduleInfo != null)
{
if (scheduleInfo.BeginTime == null)
{
scheduleInfo.BeginTime = DateTime.Now;
}
DateTimeOffset starRunTime = DateBuilder.NextGivenSecondDate(scheduleInfo.BeginTime, 1);
if (scheduleInfo.EndTime == null)
{
scheduleInfo.EndTime = DateTime.MaxValue.AddDays(-1);
}
var keys = new Dictionary <string, string>()
{
{ "RequestUrl", scheduleInfo.RequestUrl },
{ "RequestType", scheduleInfo.RequestType.ToString() },
{ "JobId", scheduleInfo.Id.ToString() }
};
DateTimeOffset endRunTime = DateBuilder.NextGivenSecondDate(scheduleInfo.EndTime, 1);
IJobDetail job = JobBuilder.Create <HttpJob>()
.SetJobData(new JobDataMap(keys))
.WithIdentity(scheduleInfo.JobName, scheduleInfo.JobGroup)
.Build();
ICronTrigger trigger = (ICronTrigger)TriggerBuilder.Create()
.StartAt(starRunTime)
.EndAt(endRunTime)
.WithIdentity(scheduleInfo.JobName, scheduleInfo.JobGroup)
.WithCronSchedule(scheduleInfo.Cron)
.Build();
await _scheduler.ScheduleJob(job, trigger);
await _scheduler.Start();
// await StopScheduleJobAsync(scheduleInfo.JobGroup, scheduleInfo.JobName);
return(true);
}
return(false);
}
catch (Exception ex)
{
return(false);
}
}
public async Task RunAsync()
{
IScheduler scheduler = await StdSchedulerFactory.GetDefaultScheduler();
DateTimeOffset startTime = DateBuilder.NextGivenSecondDate(null, 10);
IJobDetail job = JobBuilder.Create <InterruptJob>()
.WithIdentity("job1", "jobGroup1")
.Build();
ISimpleTrigger trigger = (ISimpleTrigger)TriggerBuilder.Create()
.WithIdentity("trigger1", "triggerGroup1")
.StartAt(startTime)
.WithSimpleSchedule(x => x.WithIntervalInSeconds(3).RepeatForever())
.Build();
DateTimeOffset df = await scheduler.ScheduleJob(job, trigger);
ConsoleExtend.WriteLineRed($"作业【{job.Key}】 触发器【{trigger.Key}】 执行时间【{df.LocalDateTime}】 " +
$"执行时间间隔【{trigger.RepeatInterval.Seconds}】s 重复执行次数【{trigger.RepeatCount}】");
await scheduler.Start();
Console.WriteLine("每7秒中断一次调度");
for (int i = 0; i < 50; i++)
{
await Task.Delay(TimeSpan.FromSeconds(7));
try
{
await scheduler.Interrupt(job.Key);
}
catch (Exception ex)
{
ConsoleExtend.WriteLineError(ex.Message);
}
}
await scheduler.Shutdown(true);
SchedulerMetaData metaData = await scheduler.GetMetaData();
ConsoleExtend.WriteLineDebug2($"执行了 {metaData.NumberOfJobsExecuted} 次作业.");
ConsoleExtend.WriteLineDebug2($"作业【{job.Key}】 中循环共执行了【{InterruptJob.ExecutedCount}】次" +
$"，其中成功【{InterruptJob.SuccessfulCount}】次，中断【{InterruptJob.InterruptlCount}】次");
}
/// <summary>
/// 添加一个工作调度
/// </summary>
/// <param name="m"></param>
/// <returns></returns>
private bool AddScheduleJob <T>(ScheduleEntity m) where T : IJob
{
try
{
if (m != null)
{
if (m.StarRunTime == null)
{
m.StarRunTime = DateTime.Now;
}
var starRunTime = DateBuilder.NextGivenSecondDate(m.StarRunTime, 1);
if (m.EndRunTime == null)
{
m.EndRunTime = DateTime.Now;
}
var endRunTime = DateBuilder.NextGivenSecondDate(m.EndRunTime, 1);
IJobDetail job = job = JobBuilder.Create <T>()
.WithIdentity(m.JobName, m.JobGroup).Build();
ITrigger trigger = null;
if (!string.IsNullOrEmpty(m.CronStr))
{
trigger = (ICronTrigger)TriggerBuilder.Create()
.StartAt(starRunTime)
.EndAt(endRunTime)
.WithIdentity(m.JobName, m.JobGroup)
.WithCronSchedule(m.CronStr)
.Build();
}
else
{
trigger = (ISimpleTrigger)TriggerBuilder.Create().StartAt(starRunTime).WithSimpleSchedule(x => x.WithIntervalInSeconds(1).WithRepeatCount(0)).Build();
}
Scheduler.ScheduleJob(job, trigger);
Scheduler.Start();
StopScheduleJob <ScheduleManage>(m.JobGroup, m.JobName);
return(true);
}
return(false);
}
catch (Exception ex)
{
return(false);
}
}
public static async void CreateJob <T>(string cron, DateTime?endTime = null) where T : IJob
{
var name = NewToken();
var group = NewToken();
var job = JobBuilder.Create <T>()
.WithIdentity(name, group)
.Build();
var cronTrigger = TriggerBuilder.Create()
.StartAt(DateBuilder.NextGivenSecondDate(DateTime.Now, 1))
.EndAt(endTime ?? DateTime.Now.AddYears(100))
.WithIdentity(name + "Trigger", group + "Trigger")
.WithCronSchedule(cron)
.Build();
await scheduler.ScheduleJob(job, cronTrigger);
}
private void InitializeQuartz()
{
ISchedulerFactory sf = new StdSchedulerFactory();
IScheduler sched = sf.GetScheduler();
DateTimeOffset runTime = DateBuilder.EvenMinuteDate(DateTime.UtcNow);
DateTimeOffset startTime = DateBuilder.NextGivenSecondDate(null, 5);
IJobDetail job = JobBuilder.Create<QueueConsumer>()
.WithIdentity("job1", "group1")
.Build();
ITrigger trigger = TriggerBuilder.Create()
.WithIdentity("trigger1", "group1")
.StartAt(runTime)
.WithCronSchedule("5 0/1 * * * ?")
.Build();
sched.ScheduleJob(job, trigger);
sched.Start();
}
/// <summary>
/// 添加任务计划//或者进程终止后的开启
/// </summary>
/// <returns></returns>
public async Task <bool> AddScheduleJobAsync(ScheduleInfo m)
{
try
{
if (m != null)
{
if (m.StarRunTime == null)
{
m.StarRunTime = DateTime.Now;
}
DateTimeOffset starRunTime = DateBuilder.NextGivenSecondDate(m.StarRunTime, 1);
if (m.EndRunTime == null)
{
m.EndRunTime = DateTime.MaxValue.AddDays(-1);
}
DateTimeOffset endRunTime = DateBuilder.NextGivenSecondDate(m.EndRunTime, 1);
scheduler = await GetSchedulerAsync();
IJobDetail job = JobBuilder.Create <HttpJob>()
.WithIdentity(m.JobName, m.JobGroup)
.Build();
ICronTrigger trigger = (ICronTrigger)TriggerBuilder.Create()
.StartAt(starRunTime)
.EndAt(endRunTime)
.WithIdentity(m.JobName, m.JobGroup)
.WithCronSchedule(m.CromExpress)
.Build();
//将信息写入
await _scheduleManage.AddScheduleAsync(m);
await scheduler.ScheduleJob(job, trigger);
await scheduler.Start();
await StopScheduleJobAsync(m.JobGroup, m.JobName);
return(true);
}
return(false);
}
catch (Exception ex)
{
//MyLogger.WriteError(ex, null);
return(false);
}
}
