Implémentation de la pratique d'application des tâches de synchronisation dans Spring Boot

Préface

La fonction de tâche de synchronisation est implémentée dans Spring Boot. Vous pouvez utiliser la planification des tâches de synchronisation fournie avec le ressort, ou vous pouvez utiliser le quartz de composant open source classique intégré pour obtenir la planification des tâches.

Cet article introduira en détail le contenu pertinent sur la mise en œuvre des tâches chronométrées dans Spring Boot et le partagez pour votre référence et votre apprentissage. Je ne dirai pas beaucoup ci-dessous, jetons un coup d'œil à l'introduction détaillée ensemble.

1. Minuterie de printemps

1. Méthode d'expression Cron

L'utilisation des tâches de synchronisation intégrées est très simple. Il vous suffit d'ajouter des annotations comme les suivantes et je n'ai pas besoin de hériter d'une interface de traitement de synchronisation comme le cadre de tâche de synchronisation ordinaire. L'exemple de code simple est le suivant:

 Package com.power.demo.scheduledtask.simple; import com.power.demo.util.datetimeutil; import org.springframework.scheduling.annotation.enablescheduling; import org.springframework.scheduling.annotation.scheduled; Import Org.springFramework.SteryPile.Scheduled; Import Org.spring java.util.date; @ composant @ ActiveSchedulingPublic classe Springtaska {/ ** * Cron Expression Reference: http://cron.qqe2.com/ ** / @scheduled (cron = "* / 5 * * *?", Zone = "gmt + 8: 00") private void timercron () {try ". } catch (exception e) {e.printStackTrace (); } System.out.println (String.Format ("(TIMERCRON)% S Execute toutes les 5 secondes, logging", DateTimeUtil.fmtDate (new Date ())))); }} Springtaska

Dans le code ci-dessus, ajoutez @EnablesCeduling Annotation à une classe, ajoutez @Scheduled à la méthode, configurez l'expression Cron et la tâche de synchronisation CRON la plus simple est terminée. Voici les composants de l'expression cron:

 @Scheduled (cron = "[secondes] [Minutes] [heures] [Jour du mois] [mois] [Jour de la semaine] [année]")

2. Réglage fixe et fixe

L'annotation @Scheduled élimine l'expression CRON, et il existe d'autres méthodes de configuration, telles que Fixetrate et FixedDelay. L'exemple suivant implémente différentes formes de planification des tâches de synchronisation via différentes méthodes de configuration. L'exemple de code est le suivant:

 Package com.power.demo.scheduledtask.simple; import com.power.demo.util.datetimeutil; import org.springframework.scheduling.annotation.enablescheduling; import org.springframework.scheduling.annotation.scheduled; Import Org.springFramework.SteryPile.Scheduled; Import Org.spring java.util.date; @ composant @ ActiveScheDulingPublic class SpringtaskB {/ * fixeRate: exécutez à nouveau 5 secondes après le dernier point de temps * / @scheduled (fixeRate = 5000) public void TimerFixeDrate () {try {thread.sleep (100); } catch (exception e) {e.printStackTrace (); } System.out.println (String.Format ("(FIXTRATE) Heure actuelle:% S", DateTimeUtil.fmtDate (new Date ()))); } / * fixeddelay: exécuter 5 secondes après le dernier point temporel d'exécution * / @scheduled (fixeDelay = 5000) public void TimerFixedDelay () {try {Thread.Sleep (100); } catch (exception e) {e.printStackTrace (); } System.out.println (String.Format ("(FixedDelay) Heure actuelle:% S", DateTimeUtil.fmtDate (new Date ()))); }! } catch (exception e) {e.printStackTrace (); } System.out.println (string.format ("(initdelay) Heure actuelle:% s", datetimeutil.fmtdate (new Date ()))); }} Springtaskb

Notez les principales différences:

@Scheduled(fixedRate = 5000) : exécutez à nouveau 5 secondes après le dernier point d'exécution

@Scheduled(fixedDelay = 5000) : exécutez à nouveau 5 secondes après le dernier point d'exécution

@Scheduled(initialDelay=2000, fixedDelay=5000) : exécuter après le premier retard est de 2 secondes, puis appuyez sur la règle FixedDelay pour exécuter toutes les 5 secondes

Parfois, de nombreux projets doivent être configurés et exécutés immédiatement après la configuration des tâches planifiées et InitialDelay n'est pas requise.

3. Zone

@Scheduled Annotation a également une zone d'attribut familière, indiquant le fuseau horaire. Habituellement, s'il n'est pas écrit, la tâche de synchronisation utilisera le fuseau horaire par défaut du serveur; Si votre tâche souhaite s'exécuter à un fuseau horaire spécifique et à un point temporel spécifique, par exemple, un système multilingue commun peut exécuter des scripts pour mettre à jour les données régulièrement, vous pouvez définir un fuseau horaire, comme la huitième zone est, qui peut être réglé sur:

zone = "GMT+8:00"

2. Quartz

Quartz est l'un des cadres de planification des tâches open source les plus utilisés, et de nombreuses entreprises mettent en œuvre leurs propres systèmes de gestion des tâches de synchronisation en fonction de celle-ci. Quartz fournit deux déclencheurs de tâche de synchronisation les plus couramment utilisés, à savoir SimpleTrigger et Crontrigger. Cet article prend le Crontrigger le plus utilisé comme exemple.

1. Ajouter des dépendances

 <dependency> <proupId> org.quartz-scheduler </rompuprid> <letfactId> Quartz </letefactId> <DERNÉE> 2.3.0 </ version> </Dependency>

2. Configurer les expressions cron

Comme requis pour l'exemple de code, ajoutez la configuration suivante au fichier application.properties:

 ## Quartz Timed Job Configuration Job.taska.cron = * / 3 * * *? Job.taskb.cron = * / 7 * * * *? Job.taskmail.cron = * / 5 * * * *? Job.taskmail.cron = * / 5 * * *?

En fait, nous pouvons l'écrire dans le code ou le persister dans la base de données, puis le lire sans le configurer.

3. Ajouter des tâches chronométrées pour implémenter

Tâche 1:

 Package com.power.demo.scheduledtask.quartz; import com.power.demo.util.datetimeutil; import org.quartz.disallowconcurrentExecution; import org.quartz.job; import org.quartz.jobexecutioncontex java.util.date; @disallowconcurrentExecutionPublic class Quartztaska implémente Job {@Override public void execute (jobExEcutContext var1) lève JobExEcutionException {try {thread.sleep (1); } catch (exception e) {e.printStackTrace (); } System.out.println (String.Format ("(Quartztaska)% s Execute toutes les 3 secondes, journal du journal", datetimeutil.fmtdate (new Date ()))); }} Quartztaska

Tâche 2:

 Package com.power.demo.scheduledtask.quartz; import com.power.demo.util.datetimeutil; import org.quartz.disallowconcurrentExecution; import org.quartz.job; import org.quartz.jobexecutioncontex java.util.date; @disallowconcurrentExecutionPublic class QuartzTaskB implémente Job {@Override public void execute (jobExEcutContext var1) lève JobExEcutionException {try {Thread.Sleep (100); } catch (exception e) {e.printStackTrace (); } System.out.println (String.Format ("(Quartztaskb)% S EXECUTE Toutes les 7 secondes, journal du journal", DateTimeUtil.fmtDate (new Date ()))); }} Quartztaskb

Envoyez en temps opportun les tâches par e-mail:

 Package com.power.demo.scheduledtask.quartz; import com.power.demo.service.contract.mailservice; import com.power.demo.util.datetimeutil; import com.power.demo.util.powerlogger; import org.joda.time.datetime; import org.quartz.disallowconcurrante org.quartz.job; import org.quartz.jobexecutionContext; import org.quartz.jobexeUtionException; import org.springframework.beans.factory.annotation.autowired; import java.util.date; @disallowconcurrentExecutionPublic Class MailSendTask implémente l'emploi {@aUtoWired ClassPublic MailSendTask implémente l'emploi. MailService; @Override public void execute (jobExecutionContext var1) lève JobExEcutionException {System.out.println (String.Format ("(MailSendTask)% s Envoyer du courrier toutes les 5 secondes", datetimeutil.fmtdate (new Date ()))); essayez {//thread.sleep(1); DateTime dtNow = new DateTime (new Date ()); Date starttime = dtnow.minusmonths (1) .todate (); // il y a un mois Date de fin = dtnow.plusdays (1) .todate (); MailService.AutoSend (starttime, endtime); PowerLogger.Info (String.Format ("Envoyer un courrier, heure de début:% S, Heure de fin:% S", DateTimeUtil.fmtdate (starttime), DateTimeUtil.fmtDate (Fintime))); } catch (exception e) {e.printStackTrace (); PowerLogger.info (String.Format ("Send Mail, Exception se produit:% S, Temps de fin:% S", E)); }}} MailSendTask

La mise en œuvre de tâches semble très simple, hériter de l'interface de travail de Quartz et réécrivez la méthode d'exécution.

4. Intégrer les tâches de synchronisation quartz

Comment faire en sorte que Spring reconnaisse automatiquement l'initialisation des instances de tâche de synchronisation quartz? Cela nécessite de se référer aux haricots gérés à ressort, d'exposer les haricots nécessaires aux conteneurs de ressort et de les injecter automatiquement en définissant l'usine d'emploi.

Tout d'abord, ajoutez la classe d'usine d'emploi à printemps:

 package com.power.demo.scheduledtask.quartz.config; import org.quartz.spi.triggerfiredbundle; import org.springframework.beans.factory.config.AutowirecapableBeanFactory; import org.springframework.context.applicationContext; Import org.springframework.context.applicationContextAware; import org.springframework.scheduling.quartz.springbeanjobfactory; public final classe autowirebeanjobfactory étend SpringBeanJobFactory implémente applicationContextAware {privé transitoire autowirecableBeanfactory beanfactory; / ** * Spring fournit un mécanisme qui vous permet d'obtenir ApplicationContext, c'est-à-dire l'interface ApplicationContextAware * pour une classe qui implémente l'interface ApplicationContextAware, Spring l'instanciera et appellera son * public voidSetApplicationContext (ApplicationContext ApplicationContex) lance BeanSexception; Interface, * passer le contexte auquel appartient le haricot. ** / @Override public void setApplicationContext (Final ApplicationContext Context) {beanfactory = context.getAutowiRecapableBeAnfactory (); } @Override Protected Object CreateJobinstance (Final TriggerFiredBundle Bundle) lève l'exception {Final Object Job = super.CreateJobinstance (bundle); Beanfactory.AutowireBean (Job); travail de retour; }} AutowireBeanJobfactory

Définir le quartzconfig:

 package com.power.demo.scheduledtask.quartz.config; import org.springframework.beans.factory.annotation.autowired; import org.springframework.beans.context.annotation.bean; import; org.springframework.context.annotation.configuration; import org.springframework.scheduling.quartz.crontriggerfactorybean; import org.springframework.scheduling.quartz.schedulerfactoryBean; @configurationPublic Class quartzconfig {@Autowired; @Qualifier ("Quartztaskatrigger") CronTriggerfactoryBean QuartzTaskatrigger; @Autowired @qualifier ("QuartzTaskBTrigger") private CronTriggerFactoryBean QuartzTaskBTrigger; @Autowired @Qualifier ("MailSendTrigger") private CronTriggerFactoryBean MailSendTrigger; // Le travail de Quartz injecte automatiquement l'objet hébergé par le conteneur de printemps @Bean public AutowireBeanJobFactory AutowiringsPringBeanJobFactory () {return new AutowireBeanJobFactory (); } @Bean public schedulerfactoryBean schedulerfactoryBean () {schedulerFactoryBean scheduler = new schedulerfactoryBean (); Scheduler.SetJobFactory (AutowiringsPringBeanJobFactory ()); // Configurez la classe de travail injectée par Spring // Définissez CronTriggerFactoryBean et définissez le tâche de déclenchement de tâche Scheduler.SetTriggers (QuartzTaskatrigger.getObject (), QuartztaskBtrigger.getObject (), MailSendTrigger.getObject ()); Retour planificateur; }} Quartzconfig

Ensuite, configurez les détails du travail:

 Package com.power.demo.scheduledtask.quartz.config; import com.power.demo.util.configutil; import com.power.demo.scheduledtask.quartz.quartz.quartztaska; com.power.demo.scheduledtask.quartz.quartztaskb; import com.power.demo.util.configutil; import org.springframework.context.annotation.bean; import org.springframework.context.annotation.configuration; import org.springframework.scheduling.quartz.CronTriggerFactoryBean;import org.springframework.scheduling.quartz.JobDetailFactoryBean;@Configurationpublic class TaskSetting { @Bean(name = "quartzTaskA") public JobDetailFactoryBean jobDetailAFactoryBean() { // Générer JobDetail JobDetailFactoryBean Factory = new JobDetAtailFactoryBean (); factory.setJobClass (quartztaska.class); // Définit le travail correspondant Factory.SetGroup ("QuartzTaskGroup"); factory.setName ("quartztaskajob"); factory.setdurabilité (false); factory.setDescription ("Test Task A"); Retour Factory; } @Bean (name = "Quartztaskatrigger") public CronTriggerFactoryBean CronTriggeraFactoryBean () {String cron = configUtil.getConfigval (appfield.job_taska_cron); CronTriggerFactoryBean stfactory = new CronTriggerFactoryBean (); // Définit JobDetail stfactory.setJobDetail (jobDetailAfactoryBean (). GetObject ()); stfactory.setStartDelay (1000); stfactory.setName ("QuartzTaskatrigger"); stfactory.setGroup ("QuartzTaskGroup"); stfactory.setcronexpression (Cron); retour stfactory; } @Bean (name = "Quartztaskb") public jobDetailfactoryBean jobdetailbfactoryBean () {// générer jobdetail jobdetailfactorybean factory = new JobDetailFactoryBean (); factory.setJobClass (quartztaskb.class); // Définit le travail correspondant Factory.SetGroup ("QuartzTaskGroup"); factory.setName ("QuartzTaskBJob"); factory.setdurabilité (false); factory.setDescription ("Test Task B"); Retour Factory; } @Bean (name = "QuartztaskBTrigger") CronTriggerfactoryBean CronTriggerBfactoryBean () {String cron = configUtil.getConfigval (appfield.job_taskb_cron); CronTriggerFactoryBean stfactory = new CronTriggerFactoryBean (); // Définit JobDetail stfactory.setJobDetail (jobDetailBfactoryBean (). GetObject ()); stfactory.setStartDelay (1000); stfactory.setName ("quartztaskbTrigger"); stfactory.setGroup ("QuartzTaskGroup"); stfactory.setcronexpression (Cron); retour stfactory; } @Bean (name = "MailSendTask") public jobDetailfactoryBean jobdetailmailfactorybean () {// générer jobdetail jobdetailfactorybean factory = new JobDetAtailFactoryBean (); factory.setJobClass (MailSendTask.class); // Définit le travail correspondant Factory.SetGroup ("QuartzTaskGroup"); factory.setName ("MailSendTaskJob"); factory.setdurabilité (false); factory.setDescription ("MailSendTrigger"); Retour Factory; } @Bean (name = "MailSendTrigger") CRRONTRIGHFACTORYBEAN CRONTRIGRIGHAILFACTORYBEAN () {String cron = configUtil.getConfigval (appfield.job_taskmail_cron); CronTriggerFactoryBean stfactory = new CronTriggerFactoryBean (); // Définit JobDetail stfactory.setJobDetail (jobDetailmailfactoryBean (). GetObject ()); stfactory.setStartDelay (1000); stfactory.setName ("MailSendTrigger"); stfactory.setGroup ("QuartzTaskGroup"); stfactory.setcronexpression (Cron); retour stfactory; }} Tâches

Enfin, démarrez votre application de tâche de synchronisation de démarrage Spring et une tâche de synchronisation complète basée sur le calendrier de quartz sera implémentée.

Dans cet exemple de tâche chronométré, un courrier chronométré envoie un courrier MailSendTask. Le prochain article partagera le système de messagerie simple dans l'application Spring Boot à l'aide de MongoDB comme support de stockage.

Lecture prolongée:

De nombreuses entreprises ont leur propre cadre de planification et de systèmes chronométrés. Comment intégrer le cluster Quartz dans Spring Boot pour implémenter la configuration de la tâche dynamique chronométrée?

se référer à:

//www.vevb.com/article/139591.htm

//www.vevb.com/article/139597.htm

Résumer

Ce qui précède est l'intégralité du contenu de cet article. J'espère que le contenu de cet article a une certaine valeur de référence pour l'étude ou le travail de chacun. Si vous avez des questions, vous pouvez laisser un message pour communiquer. Merci pour votre soutien à wulin.com.