Implementación de la práctica de aplicaciones de las tareas de tiempo en el arranque de primavera

Prefacio

La función de tarea de tiempo se implementa en Spring Boot. Puede usar la programación de tareas de tiempo que viene con Spring, o puede usar el cuarzo de componentes de código abierto clásico integrado para lograr la programación de tareas.

Este artículo presentará en detalle el contenido relevante sobre la implementación de tareas cronometradas en Spring Boot, y lo compartirá para su referencia y aprendizaje. No diré mucho a continuación, echemos un vistazo a la introducción detallada juntos.

1. Temporizador de primavera

1. Método de expresión cron

Usar las tareas de tiempo incorporadas es muy simple. Solo necesita agregar anotaciones como las siguientes y no necesita heredar ninguna interfaz de procesamiento de tiempo como el marco de tareas de tiempo ordinario. El código de ejemplo simple es el siguiente:

 paquete com.power.demo.scheduledtask.simple; import com.power.demo.util.datetimeutil; import org.springframework.scheduling.annotation.enablescheduling; import og.springFrame.spcheduling.annotation.scheduled; import org.springfringfryprewy java.util.date;@component@habilschedulingpublic class springTaska {/** * cron expresión referencia: http://cron.qqe2.com/ **/@scheduled (cron = " */5 * * * * *?", Zone = "GMT+8: 00") Void Timercron () {try {Hild * * * *? ", 100); } catch (Exception e) {E.PrintStackTrace (); } System.out.println (string.format ("(timercron)%s ejecutar cada 5 segundos, registro", datetimeutil.fmtdate (new date ()))); }} Springtaska

En el código anterior, agregue la anotación de @EnablesCheduling a una clase, agregue @scheduled al método, configure la expresión cron y se complete la tarea de sincronización cron más simple. Los siguientes son los componentes de la expresión cron:

 @Scheduled (cron = "[segundos] [minutos] [horas] [día del mes] [mes] [día de la semana] [año]")

2. Fijación fija y fijada

La anotación @scheduled elimina la expresión cron, y hay otros métodos de configuración, como fijación fija y fijación. El siguiente ejemplo implementa diferentes formas de programación de tareas de tiempo a través de diferentes métodos de configuración. El código de ejemplo es el siguiente:

 paquete com.power.demo.scheduledtask.simple; import com.power.demo.util.datetimeutil; import org.springframework.scheduling.annotation.enablescheduling; import og.springFrame.spcheduling.annotation.scheduled; import org.springfringfryprewy java.util.date;@component@habilschedulingpublic class springTaskb { /*fijedRate: ejecutar nuevamente 5 segundos después del último punto de tiempo* / @scheduled (fijedRate = 5000) public void timerFixedRate () {try {horthre.slele (100); } catch (Exception e) {E.PrintStackTrace (); } System.out.println (string.format ("(breedRate) hora actual: %s", datTimeUtil.fmtdate (nueva fecha ()))); } /*fijoDelay: ejecute 5 segundos después del último punto de tiempo de ejecución* / @scheduled (fixeddelay = 5000) public void timerfixedDelay () {try {hild.sleep (100); } catch (Exception e) {E.PrintStackTrace (); } System.out.println (String.Format ("(FixedDelay) Hora actual: %S", DatetimeUtil.fmtdate (nueva fecha ()))); } /*Ejecutar después del primer retraso es de 2 segundos, y luego ejecutarlo cada 5 segundos de acuerdo con la regla fixdelay* / @scheduled (initialDelay = 2000, fixeddelay = 5000) public void timerInitDelay () {try {horth.sleep (100); } catch (Exception e) {E.PrintStackTrace (); } System.out.println (string.format ("(initDelay) hora actual: %s", datetimeUtil.fmtdate (nueva fecha ()))); }} SpringTaskb

Tenga en cuenta las principales diferencias:

@Scheduled(fixedRate = 5000) : ejecute nuevamente 5 segundos después del último punto de ejecución

@Scheduled(fixedDelay = 5000) : ejecute nuevamente 5 segundos después del último punto de ejecución

@Scheduled(initialDelay=2000, fixedDelay=5000) : ejecutar después del primer retraso es de 2 segundos y luego presione la regla FixedDelay para ejecutar cada 5 segundos

A veces, muchos proyectos deben configurarse y ejecutarse inmediatamente después de configurar las tareas programadas, y no se requiere initialDelay.

3. Zona

@Scheduled Annotation también tiene una zona de atributo familiar, lo que indica la zona horaria. Por lo general, si no se escribe, la tarea de tiempo utilizará la zona horaria predeterminada del servidor; Si su tarea desea ejecutarse en una zona horaria específica y en un punto de tiempo específico, por ejemplo, un sistema multilingüe común puede ejecutar scripts para actualizar los datos regularmente, puede establecer una zona horaria, como East Octava Zone, que se puede configurar en:

zone = "GMT+8:00"

2. Cuarzo

Quartz es uno de los marcos de programación de tareas de código abierto más utilizados, y muchas compañías implementan sus propios sistemas de gestión de tareas de tiempo basados en él. Quartz proporciona dos desencadenantes de tareas de tiempo más utilizados, a saber, SimpleTrigger y Crontrigger. Este artículo toma el Crontrigger más utilizado como ejemplo.

1. Agregar dependencias

 <Spendency> <MoupRoMID> org.quartz-scheduler </groupid> <artifactid> cuarzo </artifactid> <versión> 2.3.0 </versión> </pendency>

2. Configurar expresiones cron

Como se requiere para el código de muestra, agregue la siguiente configuración al archivo Application.Properties:

 ## Cuarz Configuración de trabajo cronometrado Job.taska.cron = */3 * * * *? Job.taskb.cron = */7 * * * *? Job.taskmail.cron = */5 * * * *? Job.taskmail.cron = */5 * * * *?

De hecho, podemos escribirlo en el código o persistir en el DB y luego leerlo sin configurarlo.

3. Agregue tareas cronometradas para implementar

Tarea 1:

 paquete com.power.demo.scheduledtask.quartz; import com.power.demo.util.dateTimeUtil; import og.quartz.disallowconcurrentExecution; import org.quartz.job; import org.quartz.jobexecutionext; import ogartz.jobexecution; java.util.date; @DisallowConcurrentExecutionPublic Class QuartzTaska implementa el trabajo {@Override public void Ejecute (JobExecutionContext Var1) lanza JobExecutionException {try {Thread.seLep (1); } catch (Exception e) {E.PrintStackTrace (); } System.out.println (string.format ("(cuarztaska)%s ejecutar cada 3 segundos, registro log", datetimeUtil.fmtdate (nuevo date ()))); }} Quartztaska

Tarea 2:

 paquete com.power.demo.scheduledtask.quartz; import com.power.demo.util.dateTimeUtil; import og.quartz.disallowconcurrentExecution; import org.quartz.job; import org.quartz.jobexecutionext; import ogartz.jobexecution; java.util.date; @DisallowConcurrentExecutionPublic Class QuartzTaskb implementa el trabajo {@Override public void Ejecute (JobExecutionContext Var1) lanza JobExecutionException {try {Thread.SeLep (100); } catch (Exception e) {E.PrintStackTrace (); } System.out.println (String.Format ("(QuartzTaskb)%s Ejecutar cada 7 segundos, registro de registro", DatetimeUtil.fmtdate (nuevo date ()))); }} QuartzTaskb

Tareas de correo electrónico de envío oportuno:

 paquete com.power.demo.scheduledtask.quartz; import com.power.demo.service.contract.mailService; import org.quartz.disallowConcurrentExeCution; import org.quartz.job; import org.quartz.JobExecutionContext; import org.quartz.JobExecutionException; import Org.springFramework.Beans.Annotation.AUTOWIRED; import java.util.date; @date MailSendTask implementa el trabajo {@aUtowired private MailService MailService; @Override public void Ejecute (JobExecutionContext Var1) lanza JobExecutionException {System.out.println (String.Format ("(MailSendTask)%s Enviar correo cada 5 segundos", Datetimeutil.fmtdate (nueva fecha ()))); intente {//thread.sleep(1); DateTime dtnow = new DateTime (new Date ()); Date starttime = dtnow.minusmonths (1) .todate (); // hace un mes date endtime = dtnow.plusdays (1) .todate (); MailService.aUtosend (hora de inicio, endtime); Powerlogger.info (string.format ("Enviar correo, hora de inicio: %s, tiempo de finalización: %s", datetimeUtil.fmtdate (starttime), datetimeutil.fmtdate (endtime))); } catch (Exception e) {E.PrintStackTrace (); Powerlogger.info (string.format ("Enviar correo, excepción ocurre: %s, tiempo final: %s", e)); }}} MailsendTask

La implementación de tareas se ve muy simple, solo herede la interfaz de trabajo de Quartz y reescribe el método de ejecución.

4. Integrar tareas de tiempo de cuarzo

¿Cómo hacer que Spring reconozca automáticamente la inicialización de las instancias de tareas de tiempo de cuarzo? Esto requiere referirse a los frijoles administrados por primavera, exponer los frijoles necesarios a los contenedores de resorte, y inyectarlos automáticamente definiendo Job Factory.

Primero, agregue la clase de fábrica de trabajo inyectado por Spring:

 paquete com.power.demo.scheduledtask.quartz.config; import org.quartz.spi.riggerfiredBundle; import org.springframework.beans.factory.config.aUtowirecapableBeanFactory; import og.springframework.context.paplationContext; import org.springframework.context.ApplicationContextAware; import org.springframework.scheduling.quartz.springBeanJobFactory; public Final Clase AutoWireBeanJobFactory extiende SpringBeanJobFactory ApplicationContexTaWare {Private PRIVADO AutoWirecapable BeanFactoryFactoryFactoryFactory Factory; /*** Spring proporciona un mecanismo que le permite obtener la interfaz ApplicationContext, es decir, ApplicationContextAware* para una clase que implementa la interfaz ApplicationContextAware, Spring lo instanciará y llamará a su* público VoidSetApplicationContext (ApplicationContextContext) lanza Beansexception; interfaz, * pase el contexto al que pertenece el bean. **/ @Override public void setApplicationContext (contexto final de aplicaciones de aplicaciones) {beanFactory = context.getAutowIrecapableBeanFactory (); } @Override Objeto protegido createJobinStance (final de trigorfiredbundle) lanza la excepción {objeto final de trabajo = super.createJobinStance (paquete); BeanFactory.autowirebean (trabajo); trabajo de regreso; }} AutoWireBeanJobFactory

Defina QuartzConfig:

 paquete com.power.demo.scheduledtask.quartz.config; import org.springframework.beans.factory.annotation.aUtowired; import org.springframework.beans.factory.annotation.qualifier; import og.springframework.context.annotation.bean; import org. @Qualifier ("QuartzTaskatrigger") Private CrontriggerFactoryBean QuartzTaskatrigger; @AUTOWIRED @QUALIFIER ("QuartzTaskBTrigger") Private CronTriggerFactoryBean QuartzTaskBTrigger; @AUtowired @Qualifier ("MailSEndTrigger") Private CrontriggerFactoryBean MailSEndTrigger; // El trabajo en cuarzo inyecta automáticamente el objeto alojado por el contenedor de primavera @Bean Public AutoWirebeanJobFactory AutoWiringSpringBeanJobFactory () {return New AutoWireBeanJobFactory (); } @Bean Public SchedulerFactoryBean SchedulerFactoryBean () {SchedulerFactoryBean Scheduler = new SchedulerFactoryBean (); Scheduler.SetJobFactory (AutoWiringSpringBeanJobFactory ()); // Configure la clase de trabajo inyectada por Spring // Establecer CronTriggerFactoryBean y establecer el activador de tareas Scheduler.SetTriggers (QuartzTaskAtRigger.getObject (), QuartzTaskBTrigger.getObject (), MailSendTrigger.getObject ()); Retorno de retorno; }} Cuarzconfig

A continuación, configure los detalles del trabajo:

 paquete com.power.demo.scheduledtask.quartz.config; import com.power.demo.util.configutil; import com.power.demo.scheduledtask.quartz.mailsendtask; import com.power.demo.scheduledtask.quartz.quartaska; import; importar; import com.power.demo.scheduledtask.quartz.quartztaskb; import com.power.demo.util.configutil; import org.springframework.context.annotation.bean; import og.springframework.context.annotation.configuration; import org.springframework.scheduling.quartz.crontriggerFactoryBean; import org.springframework.scheduling.quartz.jobdetailfactoryBean; @configurationPublic Public Class Tasksingsing {@Bean (name = "QuartAzTaSka") Public JobDetaToryBean JobDetailAbean () JobDetailFactoryBean Factory = new JobDetailFactoryBean (); factory.setJobClass (QuartzTaska.Class); // establecer la fábrica de trabajo correspondiente.setGroup ("QuartzTaskGroup"); factory.setName ("QuartzTaskajob"); factory.setDurabilidad (falso); factory.setDescription ("Tarea de prueba A"); Return Factory; } @Bean (name = "QuartzTaskatrigger") public crontriggerFactoryBean CronTriggerAfactoryBean () {String cron = configUtil.getConfigVal (appfield.job_taska_cron); CrontriggerFactoryBean stFactory = new CronTriggerFactoryBean (); // establecer JobDetail stFactory.SetJobDetail (JobDetaIlaFactoryBean (). GetObject ()); stfactory.setStartDelay (1000); stfactory.setName ("QuartzTaskatrigger"); stFactory.setGroup ("QuartzTaskGroup"); stfactory.setCronexpression (cron); return stfactory; } @Bean (name = "QuartzTaskb") Public JobDetailFactoryBean JobDetailBFactoryBean () {// Generar JobDetail JobDetailFactoryBean Factory = New JobDetailFactoryBean (); Factory.SetJobClass (QuartzTaskb.Class); // establecer la fábrica de trabajo correspondiente.setGroup ("QuartzTaskGroup"); factory.setName ("QuartzTaskBJob"); factory.setDurabilidad (falso); factory.setDescription ("Tarea de prueba B"); Return Factory; } @Bean (name = "QuartzTaskBTrigger") public crontriggerFactoryBean CronTriggerBFactoryBean () {String cron = configUtil.getConfigVal (appfield.job_taskb_cron); CrontriggerFactoryBean stFactory = new CronTriggerFactoryBean (); // establecer JobDetail stFactory.SetJobDetail (JobDetailBFactoryBean (). GetObject ()); stfactory.setStartDelay (1000); stfactory.setName ("QuartzTaskBTrigger"); stFactory.setGroup ("QuartzTaskGroup"); stfactory.setCronexpression (cron); return stfactory; } @Bean (name = "MailSendTask") Public JobDetailFactoryBean JobDetailMailFactoryBean () {// Generar JobDetail JobDetailFactoryBean Factory = New JobDetailFactoryBean (); factory.setJobClass (MailSendTask.Class); // establecer la fábrica de trabajo correspondiente.setGroup ("QuartzTaskGroup"); factory.setName ("MailSendTaskJob"); factory.setDurabilidad (falso); factory.setDescription ("MailSEndTrigger"); Return Factory; } @Bean (name = "MailSEndTrigger") public crontriggerFactoryBean CrontriggermailFactoryBean () {String Cron = configUtil.getConfigVal (appfield.job_taskmail_cron); CrontriggerFactoryBean stFactory = new CronTriggerFactoryBean (); // establecer JobDetail stFactory.SetJobDetail (JobDetailMailFactoryBean (). GetObject ()); stfactory.setStartDelay (1000); stFactory.setName ("MailSEndTrigger"); stFactory.setGroup ("QuartzTaskGroup"); stfactory.setCronexpression (cron); return stfactory; }} Tareas

Finalmente, inicie su aplicación de tarea de tiempo de arranque de Spring y se implementará una tarea de sincronización completa basada en el horario de cuarzo.

En este ejemplo de la tarea cronometrada, hay una tarea de envío de correo cronometrada. El siguiente artículo compartirá el sistema de correo simple en la aplicación Spring Boot utilizando MongoDB como medio de almacenamiento.

Lectura extendida:

Muchas compañías tienen su propio marco y sistemas de programación de tareas cronometradas. ¿Cómo integrar el clúster de cuarzo en Spring Boot para implementar la configuración de tareas cronometradas dinámicas?

referirse a:

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

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

Resumir

Lo anterior es todo el contenido de este artículo. Espero que el contenido de este artículo tenga cierto valor de referencia para el estudio o el trabajo de todos. Si tiene alguna pregunta, puede dejar un mensaje para comunicarse. Gracias por su apoyo a Wulin.com.