Quartz.net官方开发指南 第二课：Jobs And Triggers

正如前面所提到的那样，通过实现I Job 接口来使你的.NET 组件可以很简单地被 scheduler 执行。下面是I Job 接口：

namespace  Quartz

{

     /**//// <summary> 

     /// The interface to be implemented by classes which represent a 'job' to be

     /// performed.

     /// </summary>

     /// <remarks>

     /// Instances of this interface must have a <see langword="public" />

     /// no-argument constructor. <see cref="JobDataMap" /> provides a mechanism for 'instance member data'

     /// that may be required by some implementations of this interface.

    /// </remarks>

     /// <seealso cref="JobDetail" />

     /// <seealso cref="IStatefulJob" />

     /// <seealso cref="Trigger" />

     /// <seealso cref="IScheduler" />

     /// <author>James House</author>

     /// <author>Marko Lahma (.NET)</author>

     public interface IJob

     {

         /**//// <summary>

         /// Called by the <see cref="IScheduler" /> when a <see cref="Trigger" />

         /// fires that is associated with the <see cref="IJob" />.

        /// </summary>

         /// <remarks>

         /// The implementation may wish to set a  result object on the 

         /// JobExecutionContext before this method exits.  The result itself

         /// is meaningless to Quartz, but may be informative to 

         /// <see cref="IJobListener" />s or 

         /// <see cref="ITriggerListener" />s that are watching the job's 

         /// execution.

         /// </remarks>

         /// <param name="context">The execution context.</param>

         void Execute(JobExecutionContext context);

     }

}

             ILog log  =  LogManager.GetLogger( typeof  (SimpleTriggerExample));

            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 ---------------- " );

             //  jobs can be scheduled before sched.start() has been called

             //  get a "nice round" time a few seconds in the future
            DateTime ts  =  TriggerUtils.GetNextGivenSecondDate( null ,  15 );

             //  job1 will only fire once at date/time "ts"
            JobDetail job  =   new  JobDetail( " job1 " ,  " group1 " ,  typeof  (SimpleJob));
            SimpleTrigger trigger  =   new  SimpleTrigger( " trigger1 " ,  " group1 " , ts);

             //  schedule it to run!
            DateTime ft  =  sched.ScheduleJob(job, trigger);
            log.Info( string .Format( " {0} will run at: {1} and repeat: {2} times, every {3} seconds " , 
                job.FullName, ft.ToString( " r " ), trigger.RepeatCount, (trigger.RepeatInterval / 1000 )));

             //  job2 will only fire once at date/time "ts"
            job  =   new  JobDetail( " job2 " ,  " group1 " ,  typeof  (SimpleJob));
            trigger  =   new  SimpleTrigger( " trigger2 " ,  " group1 " ,  " job2 " ,  " group1 " , ts,  null ,  0 ,  0 );
            ft  =  sched.ScheduleJob((job), trigger);
            log.Info( string .Format( " {0} will run at: {1} and repeat: {2} times, every {3} seconds " , 
                job.FullName, ft.ToString( " r " ), trigger.RepeatCount, (trigger.RepeatInterval / 1000 )));

             //  job3 will run 11 times (run once and repeat 10 more times)
             //  job3 will repeat every 10 seconds (10000 ms)
            job  =   new  JobDetail( " job3 " ,  " group1 " ,  typeof  (SimpleJob));
            trigger  =   new  SimpleTrigger( " trigger3 " ,  " group1 " ,  " job3 " ,  " group1 " , ts,  null ,  10 ,  10000L );
            ft  =  sched.ScheduleJob(job, trigger);
            log.Info( string .Format( " {0} will run at: {1} and repeat: {2} times, every {3} seconds " , 
                job.FullName, ft.ToString( " r " ), trigger.RepeatCount, (trigger.RepeatInterval / 1000 )));

             //  the same job (job3) will be scheduled by a another trigger
             //  this time will only run every 70 seocnds (70000 ms)
            trigger  =   new  SimpleTrigger( " trigger3 " ,  " group2 " ,  " job3 " ,  " group1 " , ts,  null ,  2 ,  70000L );
            ft  =  sched.ScheduleJob(trigger);
            log.Info( string .Format( " {0} will [also] run at: {1} and repeat: {2} times, every {3} seconds " , 
                job.FullName, ft.ToString( " r " ), trigger.RepeatCount, (trigger.RepeatInterval / 1000 )));

             //  job4 will run 6 times (run once and repeat 5 more times)
             //  job4 will repeat every 10 seconds (10000 ms)
            job  =   new  JobDetail( " job4 " ,  " group1 " ,  typeof  (SimpleJob));
            trigger  =   new  SimpleTrigger( " trigger4 " ,  " group1 " ,  " job4 " ,  " group1 " , ts,  null ,  5 ,  10000L );
            ft  =  sched.ScheduleJob(job, trigger);
            log.Info( string .Format( " {0} will run at: {1} and repeat: {2} times, every {3} seconds " , 
                job.FullName, ft.ToString( " r " ), trigger.RepeatCount, (trigger.RepeatInterval / 1000 )));

             //  job5 will run once, five minutes past "ts" (300 seconds past "ts")
            job  =   new  JobDetail( " job5 " ,  " group1 " ,  typeof  (SimpleJob));
            trigger  =   new  SimpleTrigger( " trigger5 " ,  " group1 " ,  " job5 " ,  " group1 " , ts.AddMilliseconds( 300 * 1000 ),  null ,  0 ,  0 );
            ft  =  sched.ScheduleJob(job, trigger);
            log.Info( string .Format( " {0} will run at: {1} and repeat: {2} times, every {3} seconds " , 
                job.FullName, ft.ToString( " r " ), trigger.RepeatCount, (trigger.RepeatInterval / 1000 )));

             //  job6 will run indefinitely, every 50 seconds
            job  =   new  JobDetail( " job6 " ,  " group1 " ,  typeof  (SimpleJob));
            trigger  =
                 new  SimpleTrigger( " trigger6 " ,  " group1 " ,  " job6 " ,  " group1 " , ts,  null , SimpleTrigger.REPEAT_INDEFINITELY,
                                   50000L );
            ft  =  sched.ScheduleJob(job, trigger);
            log.Info( string .Format( " {0} will run at: {1} and repeat: {2} times, every {3} seconds " , 
                job.FullName, ft.ToString( " r " ), trigger.RepeatCount, (trigger.RepeatInterval / 1000 )));

            log.Info( " ------- Starting Scheduler ---------------- " );

             //  All of the jobs have been added to the scheduler, but none of the jobs
             //  will run until the scheduler has been started
            sched.Start();

            log.Info( " ------- Started Scheduler ----------------- " );

             //  jobs can also be scheduled after start() has been called
             //  job7 will repeat 20 times, repeat every five minutes
            job  =   new  JobDetail( " job7 " ,  " group1 " ,  typeof  (SimpleJob));
            trigger  =   new  SimpleTrigger( " trigger7 " ,  " group1 " ,  " job7 " ,  " group1 " , ts,  null ,  20 ,  300000 );
            ft  =  sched.ScheduleJob(job, trigger);
            log.Info( string .Format( " {0} will run at: {1} and repeat: {2} times, every {3} seconds " , 
                job.FullName, ft.ToString( " r " ), trigger.RepeatCount, (trigger.RepeatInterval / 1000 )));

             //  jobs can be fired directly (rather than waiting for a trigger)
            job  =   new  JobDetail( " job8 " ,  " group1 " ,  typeof  (SimpleJob));
            job.Durable  =  ( true );
            sched.AddJob(job,  true );
            log.Info( " 'Manually' triggering job8 " );
            sched.TriggerJob( " job8 " ,  " group1 " );

            log.Info( " ------- Waiting 30 seconds -------------- " );

             try
             {
                // wait 30 seconds to show jobs
                Thread.Sleep(30*1000);
                // executing
            }
             catch  (ThreadInterruptedException)
             {
            }

             //  jobs can be re-scheduled  
             //  job 7 will run immediately and repeat 10 times for every second
            log.Info( " ------- Rescheduling -------------------- " );
            trigger  =   new  SimpleTrigger( " trigger7 " ,  " group1 " ,  " job7 " ,  " group1 " , DateTime.Now,  null ,  10 ,  1000L );
            NullableDateTime ft2  =  sched.RescheduleJob( " trigger7 " ,  " group1 " , trigger);
             if  (ft2.HasValue)
             {
                log.Info("job7 rescheduled to run at: " + ft2.Value.ToString("r"));
            }
             else
             {
                log.Error("Reschedule failed, date was null");
            }

            log.Info( " ------- Waiting five minutes ------------ " );
             try
             {
                // wait five minutes to show jobs
                Thread.Sleep(2*1000);
                // executing
            }
             catch  (ThreadInterruptedException)
             {
            }

            log.Info( " ------- Shutting Down --------------------- " );

            sched.Shutdown( true );

            log.Info( " ------- Shutdown Complete ----------------- " );

             //  display some stats about the schedule that just ran
            SchedulerMetaData metaData  =  sched.GetMetaData();
            log.Info( string .Format( " Executed {0} jobs. " , metaData.NumJobsExecuted));

    这样，你会猜想出，当 Job 触发器触发时（在某个时刻）， Execute (..) 就被 scheduler 所调用。 JobExecutionContext 对象被传递给这个方法，它为 Job 实例提供了它的 “ 运行时 ” 环境 - 一个指向执行这个I Job 实例的 Scheduler 句柄，一个指向触发该次执行的触发器的句柄，I Job 的 JobDetail 对象以及一些其他的条目。

JobDetail 对象由 Quartz 客户端在 Job 被加入到 scheduler 时创建。它包含了 Job 的各种设置属性以及一个 JobDataMap 对象，这个对象被用来存储给定 Job 类实例的状态信息。

      Trigger 对象被用来触发 jobs 的执行。你希望将任务纳入到进度，要实例化一个 Trigger 并且 “ 调整 ” 它的属性以满足你想要的进度安排。 Triggers 也有一个 JobDataMap 与之关联，这非常有利于向触发器所触发的 Job 传递参数。 Quartz 打包了很多不同类型的 Trigger, 但最常用的 Trigge 类是 SimpleTrigger 和 CronTrigger 。

SimpleTrigger 用来触发只需执行一次或者在给定时间触发并且重复 N 次且每次执行延迟一定时间的任务。 CronTrigger 按照日历触发，例如 “ 每个周五 ” ，每个月 10 日中午或者 10 ： 15 分。

为什么要分为 Jobs 和 Triggers? 很多任务日程管理器没有将 Jobs 和 Triggers 进行区分。一些产品中只是将 “ job ” 简单地定义为一个带有一些小任务标识的执行时间。其他产品则更像 Quartz 中 job 和 trigger 的联合。而开发 Quartz 的时候，我们决定对日程和按照日程执行的工作进行分离。（从我们的观点来看）这有很多好处。

例如： jobs 可以被创建并且存储在 job scheduler 中，而不依赖于 trigger, 而且，很多 triggers 可以关联一个 job. 另外的好处就是这种 “ 松耦合 ” 能使与日程中的 Job 相关的 trigger 过期后重新配置这些 Job, 这样以后就能够重新将这些 Job 纳入日程而不必重新定义它们。这样就可以更改或者替换 trigger 而不必重新定义与之相连的 job 标识符。

当向 Quartz scheduler 中注册 Jobs 和 Triggers 时，它们要给出标识它们的名字。 Jobs 和 Triggers 也可以被放入 “ 组 ” 中。 “ 组 ” 对于后续维护过程中，分类管理 Jobs 和 Triggers 非常有用。 Jobs 和 Triggers 的名字在组中必须唯一，换句话说， Jobs 和 Triggers 真实名字是它的名字 + 组。如果使 Job 或者 Trigger 的组为 ‘ null ’ ，这等价于将其放入缺省的 Scheduler.DEFAULT_GROUP 组中。

现在对什么是 Jobs 和 Triggers 有了一般性的认识，可以通过第三课 :更多关于Jobs和JobDetails 的内容及第四课 :关于Triggers 更多的内容来深入地学习它们。

自由、创新、研究、探索……