Introduction détaillée aux exemples de configuration du cadre de planification Quartz.Net

Cet article présente principalement en détail la méthode de configuration du cadre de planification Quartz.Net, qui a une certaine valeur de référence. Les amis intéressés peuvent s'y référer

Dans le travail quotidien, on estime que la plupart d'entre eux l'ont. effectué des tâches de planification d'interrogation, telles que la synchronisation programmée de la base de données d'interrogation, les notifications programmées par e-mail, etc. Tout le monde a implémenté de telles tâches via des tâches planifiées Windows, des services Windows, etc., et a même implémenté son propre cadre de configuration personnalisé. Aujourd'hui, je vais donc présenter le framework de planification open source Quartz.Net (présentant principalement l'implémentation de la configuration, car un ami a posé de telles questions). Le code d'implémentation de la planification est très simple. Il y a beaucoup de démos dans le code source, qui seront ignorées ici.

La dernière version de Quartz.Net, Quartz.NET 2.0 bêta 1 publiée

1. Configuration basée sur des fichiers

Jetons un coup d'œil à le code d'implémentation simple d'abord

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using Quartz;
using Quartz.Impl;
using Common.Logging;

namespace Demo
{
 class Program
 {
  static void Main(string[] args)
  {
   
   // First we must get a reference to a scheduler
   ISchedulerFactory sf = new StdSchedulerFactory();
   IScheduler sched = sf.GetScheduler();
   
   sched.Start();   
   sched.Shutdown(true);
   
  }
 }
}

Le code est très simple. Comment la configuration de base du quartz dans le fichier de configuration, ainsi que les informations sur les tâches et les déclencheurs sont-elles chargées ? Ce processus se produit IScheduler sched = sf.GetScheduler(); process, principalement reflété dans la section du code source

 public void Initialize()
  {
   // short-circuit if already initialized
   if (cfg != null)
   {
    return;
   }
   if (initException != null)
   {
    throw initException;
   }

   NameValueCollection props = (NameValueCollection) ConfigurationManager.GetSection("quartz");

   string requestedFile = Environment.GetEnvironmentVariable(PropertiesFile);
   string propFileName = requestedFile != null && requestedFile.Trim().Length > 0 ? requestedFile : "~/quartz.config";

   // check for specials
   propFileName = FileUtil.ResolveFile(propFileName);

   if (props == null && File.Exists(propFileName))
   {
    // file system
    try
    {
     PropertiesParser pp = PropertiesParser.ReadFromFileResource(propFileName);
     props = pp.UnderlyingProperties;
     Log.Info(string.Format("Quartz.NET properties loaded from configuration file '{0}'", propFileName));
    }
    catch (Exception ex)
    {
     Log.Error("Could not load properties for Quartz from file {0}: {1}".FormatInvariant(propFileName, ex.Message), ex);
    }

   }
   if (props == null)
   {
    // read from assembly
    try
    {
     PropertiesParser pp = PropertiesParser.ReadFromEmbeddedAssemblyResource("Quartz.quartz.config");
     props = pp.UnderlyingProperties;
     Log.Info("Default Quartz.NET properties loaded from embedded resource file");
    }
    catch (Exception ex)
    {
     Log.Error("Could not load default properties for Quartz from Quartz assembly: {0}".FormatInvariant(ex.Message), ex);
    }
   }
   if (props == null)
   {
    throw new SchedulerConfigException(
     @"Could not find <quartz> configuration section from your application config or load default configuration from assembly.
Please add configuration to your application config file to correctly initialize Quartz.");
   }
   Initialize(OverrideWithSysProps(props));
  }

Grâce à l'analyse du code ci-dessus, l'initialisation vérifiera d'abord s'il existe un nœud de section de configuration dans la configuration du système (config fait référence à app.config, web.config). Si la configuration du système a un nœud de quartz, chargez les informations de configuration directement ici. Si la configuration système ne dispose pas des informations de configuration de base de quartz, elle continuera à rechercher l'existence des deux fichiers de configuration quartz.config/Quartz.quartz.config. Si tel est le cas, les informations de configuration seront chargées. une exception de configuration d'initialisation sera levée.

Et jobs.xml (tâche planifiée et fichier de configuration du nœud du plugin de déclenchement)

Configuration du plugin App.config/web.config

 <quartz>
  <add key="quartz.scheduler.instanceName" value="ExampleDefaultQuartzScheduler"/>
  <add key="quartz.threadPool.type" value="Quartz.Simpl.SimpleThreadPool, Quartz"/>
  <add key="quartz.threadPool.threadCount" value="10"/>
  <add key="quartz.threadPool.threadPriority" value="2"/>
  <add key="quartz.jobStore.misfireThreshold" value="60000"/>
  <add key="quartz.jobStore.type" value="Quartz.Simpl.RAMJobStore, Quartz"/>
 <!--******************************Plugin配置********************************************* -->
 <add key="quartz.plugin.xml.type" value="Quartz.Plugin.Xml.XMLSchedulingDataProcessorPlugin, Quartz" />
 <add key="quartz.plugin.xml.fileNames" value="quartz_jobs.xml"/> 
 </quartz>

La configuration du plugin dans quartz.config pointe vers (quartz.plugin.xml.type / quartz.plugin.xml.fileNames)

# You can configure your scheduler in either <quartz> configuration section
# or in quartz properties file
# Configuration section has precedence

quartz.scheduler.instanceName = ServerScheduler

# configure thread pool info
quartz.threadPool.type = Quartz.Simpl.SimpleThreadPool, Quartz
quartz.threadPool.threadCount = 10
quartz.threadPool.threadPriority = Normal

#--------------------------------*************plugin配置------------------------------------
# job initialization plugin handles our xml reading, without it defaults are used
quartz.plugin.xml.type = Quartz.Plugin.Xml.XMLSchedulingDataProcessorPlugin, Quartz
quartz.plugin.xml.fileNames = ~/quartz_jobs.xml

# export this server to remoting context
quartz.scheduler.exporter.type = Quartz.Simpl.RemotingSchedulerExporter, Quartz
quartz.scheduler.exporter.port = 555
quartz.scheduler.exporter.bindName = QuartzScheduler
quartz.scheduler.exporter.channelType = tcp
quartz.scheduler.exporter.channelName = httpQuartz

2. Méthode basée sur le code

Cette situation est réalisée directement via le code De nombreuses DEMO officielles sont comme ça

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text; using Quartz;
using Quartz.Impl;
using System.Threading;
using Common.Logging;

namespace Demo
{
 class Program
 {
  static void Main(string[] args)
  {
   ILog log = LogManager.GetLogger(typeof(Demo.HelloJob));

   log.Info("------- Initializing ----------------------");

   // First we must get a reference to a scheduler
   ISchedulerFactory sf = new StdSchedulerFactory();
   IScheduler sched = sf.GetScheduler();

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


   //---------------------------------------代码添加job和trigger
   // computer a time that is on the next round minute
   DateTimeOffset runTime = DateBuilder.EvenMinuteDate(DateTimeOffset.UtcNow);

   log.Info("------- Scheduling Job -------------------");

   // define the job and tie it to our HelloJob class
   IJobDetail job = JobBuilder.Create<HelloJob>()
    .WithIdentity("job1", "group1")
    .Build();

   // Trigger the job to run on the next round minute
   ITrigger trigger = TriggerBuilder.Create()
    .WithIdentity("trigger1", "group1")
    .StartAt(runTime)
    .Build();

   // Tell quartz to schedule the job using our trigger
   sched.ScheduleJob(job, trigger);
   log.Info(string.Format("{0} will run at: {1}", job.Key, runTime.ToString("r")));

   // Start up the scheduler (nothing can actually run until the 
   // scheduler has been started)
   sched.Start();
   log.Info("------- Started Scheduler -----------------");

   // wait long enough so that the scheduler as an opportunity to 
   // run the job!
   log.Info("------- Waiting 65 seconds... -------------");

   // wait 65 seconds to show jobs
   Thread.Sleep(TimeSpan.FromSeconds(65));

   // shut down the scheduler
   log.Info("------- Shutting Down ---------------------");
   sched.Shutdown(true);
   log.Info("------- Shutdown Complete -----------------");
  }
 }
}

<. 🎜>En fait, la méthode code a été mélangée avec le fichier de configuration. Mais cette méthode consiste à charger le travail et à déclencher la configuration via une association de configuration. Nous avons également une troisième méthode, qui consiste à charger le travail et à déclencher les fichiers de configuration nous-mêmes.

3. Chargez manuellement le fichier de configuration

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text; 
using Quartz;
using Quartz.Xml;
using Quartz.Impl;
using Quartz.Simpl;
using System.Threading;
using Common.Logging;
using System.IO;

namespace Demo
{
 class Program
 {
  static void Main(string[] args)
  {    
   XMLSchedulingDataProcessor processor = new XMLSchedulingDataProcessor(new SimpleTypeLoadHelper());
   ISchedulerFactory sf = new StdSchedulerFactory();
   IScheduler scheduler = sf.GetScheduler();

   Stream s = new StreamReader("~/quartz.xml").BaseStream;
   processor.ProcessStream(s, null);
   processor.ScheduleJobs(scheduler);

   scheduler.Start();
   scheduler.Shutdown();
   
  }
 }
}

Ou ceci :

using System.Text; 
using Quartz;
using Quartz.Xml;
using Quartz.Impl;
using Quartz.Simpl;
using System.Threading;
using Common.Logging;
using System.IO;

namespace Demo
{
 class Program
 {
  static void Main(string[] args)
  {    
   XMLSchedulingDataProcessor processor = new XMLSchedulingDataProcessor(new SimpleTypeLoadHelper());
   ISchedulerFactory sf = new StdSchedulerFactory();
   IScheduler scheduler = sf.GetScheduler();

   
   processor.ProcessFileAndScheduleJobs("~/quartz.xml",scheduler);
   
   scheduler.Start();
   scheduler.Shutdown();
   
  }
 }
}

Actuellement, sur la base de l'analyse du code source, il existe à peu près ces méthodes de configuration, qui sont très flexibles et peuvent être combinées de n'importe quelle manière. Le code source d'utilisation du quartz est très détaillé et il existe de nombreux articles d'apprentissage dans le jardin.

Rappelez-vous que la méthode de lecture de la configuration du quartz est d'abord app.config/web.config ---->quartz.config/Quartz.quartz.config ---->quartz_jobs.xml .

Grâce au code, nous pouvons changer le point de quartz_jobs.xml vers le fichier XML nouvellement nommé

(Le quartz_jobs.xml par défaut est spécifié dans XMLSchedulingDataProcessor.QuartzXmlFileName = "quartz_jobs.xml")

Méthode 1, pointez vers le jobs.xml spécifié via quartz node/quartz.config.

Méthode 2, chargez le fichier jobs.xml spécifié via XMLSchedulingDataProcessor

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!