Analyse approfondie du Job et du JobDetail de Quartz

L'éditeur suivant vous apportera une analyse approfondie de Job et JobDetail dans Quartz. L'éditeur pense que c'est plutôt bien, alors je vais le partager avec vous maintenant et le donner comme référence. Suivons l'éditeur et jetons un coup d'oeil

A quoi peut servir le Quartz ?

Quartz est un framework de planification de tâches. Par exemple, si vous rencontrez un tel problème

Vous souhaitez rembourser automatiquement votre carte bancaire le 25 de chaque mois

Vous souhaitez envoyer un message à la déesse que tu as secrètement aimé le 1er avril de chaque année Une carte de voeux anonyme

Je souhaite sauvegarder mes notes d'étude de film d'action d'amour sur le disque cloud toutes les heures

Le résumé de ces questions est le suivant : Faites quelque chose à une heure régulière. Et les conditions de déclenchement temporel peuvent être très complexes (par exemple, 17h50 le dernier jour ouvrable de chaque mois), si complexes qu'un cadre spécial est nécessaire pour ce faire. Quartz est là pour faire ce genre de chose. Vous lui donnez une définition des conditions de déclenchement, et il est responsable du déclenchement du Job correspondant pour qu'il commence à fonctionner à ce moment précis.

Fin de bêtises, le code est génial. . .

public static void main(String[] args) {
   try { //创建scheduler
  Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();

  //定义一个Trigger
  Trigger trigger =TriggerBuilder.newTrigger().withIdentity("trigger1", "group1") //定义name/group
    .startNow()//一旦加入scheduler，立即生效
    .withSchedule(SimpleScheduleBuilder.simpleSchedule() //使用SimpleTrigger
      .withIntervalInSeconds(1) //每隔一秒执行一次
      .repeatForever()) //一直执行
    .build();
  //定义一个JobDetail
  JobDetail job =JobBuilder.newJob(HelloQuartz.class) //定义Job类为HelloQuartz类，这是真正的执行逻辑所在
    .withIdentity("job1", "group1") //定义name/group
    .usingJobData("name", "quartz") //定义属性
    .build();
  //加入这个调度
  scheduler.scheduleJob(job, trigger);
  //启动之
  scheduler.start();
  //运行一段时间后关闭
   Thread.sleep(10000);
   scheduler.shutdown(true);
  } catch (Exception e) {
  e.printStackTrace();
}

}

Classe HelloQuartz

public class HelloQuartz implements Job {
  public void execute(JobExecutionContext context) throws JobExecutionException {
    JobDetail detail = context.getJobDetail();
    String name = detail.getJobDataMap().getString("name");
    System.out.println("say hello to " + name + " at " + new Date());
  }
}

package jar :

Cet exemple couvre très bien les trois éléments de base les plus importants de Quartz :

Scheduler : planificateur. Toute la planification est contrôlée par celui-ci.

Déclencheur : Définir les conditions de déclenchement. Dans l'exemple, son type est SimpleTrigger, qui est exécuté toutes les 1 seconde (ce qu'est SimpleTrigger sera décrit en détail ci-dessous).

JobDetail & Job : JobDetail définit les données de la tâche, et la véritable logique d'exécution est dans le Job, dans l'exemple il s'agit de HelloQuartz. Pourquoi est-il conçu comme JobDetail + Job au lieu d'utiliser Job directement ? En effet, les tâches peuvent être exécutées simultanément Si le planificateur utilise le Job directement, il y aura un problème d'accès simultané à la même instance du Job. Dans la méthode JobDetail & Job, chaque fois que le planificateur est exécuté, une nouvelle instance de Job sera créée sur la base de JobDetail, afin d'éviter le problème de l'accès simultané.

Scheduler

Scheduler est le cerveau de Quartz, et toutes les tâches sont mises en œuvre par lui.

Schduelr contient deux composants importants : JobStore et ThreadPool.

JobStore stockera les informations d'exécution, notamment le déclencheur, le planificateur, le JobDetail, le verrouillage professionnel, etc. Il a plusieurs implémentations RAMJob (implémentation de la mémoire), JobStoreTX (JDBC, les transactions sont gérées par Quartz), JobStoreCMT (JDBC, utilisant des transactions de conteneurs), ClusteredJobStore (implémentation de cluster), TerracottaJobStore (qu'est-ce que Terraractta).

ThreadPool est un pool de threads et Quartz a sa propre implémentation de pool de threads. Toutes les tâches seront exécutées par le pool de threads.

SchedulerFactory

SchdulerFactory, comme son nom l'indique, est utilisé pour créer Schduler. Il existe deux implémentations : DirectSchedulerFactory et StdSchdulerFactory. Le premier peut être utilisé pour personnaliser vos propres paramètres Schduler dans le code. Ce dernier lit directement la configuration quartz.properties sous le classpath (s'il n'existe pas, utilisez la valeur par défaut ) pour instancier Schduler. D'une manière générale, il nous suffit d'utiliser StdSchdulerFactory.

SchdulerFactory lui-même prend en charge la création de stubs RMI, qui peuvent être utilisés pour gérer les planificateurs distants. Les fonctions sont les mêmes que celles locales et les tâches peuvent être soumises à distance.

1.job

classe d'implémentation JobDetail

JobDetail job = JobBuilder.newJob(RemindJob.class)
      .withIdentity("job1", "group1").build();//创建一个任务

  
   /**
   * 创建触发器
   * 第一种方式 不太好
   */
  SimpleTrigger trigger = TriggerBuilder.newTrigger().withIdentity("myTrigger", "myTriggerGroup").
  withSchedule(SimpleScheduleBuilder.simpleSchedule().
      withIntervalInSeconds(3).
      repeatForever()).
      startAt(new Date(System.currentTimeMillis()+1000)).build();
  
  
  /**
   * 创建触发器
   * 第二种 方式 非常好
   * 可以 好用 2013年每月的第三个星期五上午10:30触发 0 30 10 ? * 6#3 2013
   * 2016年每月的第一个星期四下午16:17触发  0 17 16 ? * 5#1 2016
   * 每天15点到16点每5分钟运行一次，此外，每天17点到18点每5分钟运行一次 

   */
  /*CronTrigger trigger=TriggerBuilder.newTrigger() 
      .withIdentity("myTrigger", "myTriggerGroup")
      .withSchedule(CronScheduleBuilder.cronSchedule("0 18 16 ? * 5#1 2016")).build();*/
  
  SchedulerFactory sf=new StdSchedulerFactory();//创建调度者工厂
  Scheduler scheduler = sf.getScheduler();//创建一个调度者
  scheduler.scheduleJob(job,trigger);//注册并进行调度
  scheduler.start();//启动调度
  
  //Thread.sleep(millis)
  
  //scheduler.shutdown();//关闭调度

Classe RemindJob La définition de

*/
public class RemindJob implements Job {
private RemindService service=new RemindService();
  @Override
  public void execute(JobExecutionContext context) throws JobExecutionException {
    service.printPlan("你好！");
    
    Date date=new Date();
    String time = date.toString();
    System.out.println(time+"job is starting");
  }

peut être vue que nous passons une instance de JobDetail au planificateur car lorsque nous créons JobDetail, nous transmettons le nom de classe du travail à exécuter à JobDetail , afin que le planificateur sache quel type de travail exécuter ; chaque fois que le planificateur exécute le travail, une nouvelle instance de la classe sera créée avant d'appeler sa méthode execute(...) après l'exécution, la référence à l'instance ; sera rejeté, l'instance sera récupérée ; une conséquence de cette stratégie d'exécution est que le travail doit avoir un

constructeur sans paramètre (lors de l'utilisation du JobFactory par défaut, une autre conséquence est, dans une classe de travail,) ; Les propriétés de données avec état ne doivent pas être définies car les valeurs de ces propriétés ne sont pas conservées lors de plusieurs exécutions du travail.

Alors, comment ajouter des attributs ou une configuration à l'instance de travail ? Comment suivre l'état d'un travail lors de plusieurs exécutions du travail ? La réponse est : JobDataMap, une partie de l'objet JobDetail

.

JobDataMap

JobDataMap peut contenir un nombre illimité d'objets de données (sérialisés), et les données peuvent être utilisées lorsque l'instance de travail est exécutée. JobDataMap est Java Une implémentation de Map ; interface qui ajoute quelques méthodes supplémentaires pour faciliter l’accès aux types de données de base.

将job加入到scheduler之前，在构建JobDetail时，可以将数据放入JobDataMap，如下示例：

JobDetail job=JobBuilder.newJob(RemindJob.class)
      .withIdentity("job1", "group1")
      .usingJobData("hello", "we are family")
      .build();

在job的执行过程中，可以从JobDataMap中取出数据，如下示例：

@Override
  public void execute(JobExecutionContext context) throws JobExecutionException {
    service.printPlan("你好！");
    JobKey key=context.getJobDetail().getKey();
    
    JobDataMap map = context.getJobDetail().getJobDataMap();
    String string = map.getString("hello");
    System.out.println(key+"==========="+string);
    
    Date date=new Date();
    String time = date.toString();
    System.out.println(time+"job is starting");
  }

如果你使用的是持久化的存储机制（本教程的JobStore部分会讲到），在决定JobDataMap中存放什么数据的时候需要小心，因为JobDataMap中存储的对象都会被序列化，因此很可能会导致类的版本不一致的问题；Java的标准类型都很安全，如果你已经有了一个类的序列化后的实例，某个时候，别人修改了该类的定义，此时你需要确保对类的修改没有破坏兼容性；更多细节，参考现实中的序列化问题。另外，你也可以配置JDBC-JobStore和JobDataMap，使得map中仅允许存储基本类型和String类型的数据，这样可以避免后续的序列化问题。

如果你在job类中，为JobDataMap中存储的数据的key增加set方法（如在上面示例中，增加setJobSays(String val)方法），那么Quartz的默认JobFactory实现在job被实例化的时候会自动调用这些set方法，这样你就不需要在execute()方法中显式地从map中取数据了。

在Job执行时，JobExecutionContext中的JobDataMap为我们提供了很多的便利。它是JobDetail中的JobDataMap和Trigger中的JobDataMap的并集，但是如果存在相同的数据，则后者会覆盖前者的值。

下面的示例，在job执行时，从JobExecutionContext中获取合并后的JobDataMap：

@Override
  public void execute(JobExecutionContext context) throws JobExecutionException {
    service.printPlan("你好！");
    JobKey key=context.getJobDetail().getKey();
    
  /*  JobDataMap map = context.getJobDetail().getJobDataMap();
    String string = map.getString("hello");
    System.out.println(key+"==========="+string);*/


     JobDataMap map = context.getMergedJobDataMap();
     String string = map.getString("hello");
     System.out.println(key+"---------------------  "+string);

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!