Implementando a prática de aplicação das tarefas de tempo na inicialização da primavera

Prefácio

A função de tarefa de tempo é implementada na inicialização da primavera. Você pode usar o agendamento de tarefas de tempo que vem com a primavera ou pode usar o quartzo do componente de código aberto clássico integrado para obter o agendamento de tarefas.

Este artigo introduzirá em detalhes o conteúdo relevante sobre a implementação de tarefas cronometradas no Spring Boot e compartilhará -o para sua referência e aprendizado. Não vou dizer muito abaixo, vamos dar uma olhada na introdução detalhada juntos.

1. Timer de primavera

1. Método de expressão de Cron

O uso das tarefas de tempo interno é muito simples. Você só precisa adicionar anotações como o seguinte e não precisar herdar nenhuma interface de processamento de tempo, como a estrutura de tarefa de tempo comum. O código de exemplo simples é o seguinte:

 pacote com.power.demo.scheduledTask.simple; importar com.power.demo.util.dateTimeUtil; importar org.springframework.scheduling.annotation.enablesCheduling; import org.springframework.sChedinging.Notation.SchedulEd; Import.mmport; java.util.date;@componente@enablechedulingpublic classe springtaska {/** * Referência de expressão de cron: http://cron.qqe2.com/ **/@scheduled (cron = " */5 * * *? } catch (Exceção e) {e.printStackTrace (); } System.out.println (String.Format ("(TimeRcron)%S execute a cada 5 segundos, registrando", DateTimeutil.fmtdate (new Date ()))); }} Springtaska

No código acima, adicione @enablescheduling anotação a uma classe, adicione @Scheduled ao método, configure a expressão de Cron e a tarefa de tempo mais simples do cron é concluída. A seguir, estão os componentes da expressão de Cron:

 @Scheduled (cron = "[segundos] [minutos] [horas] [dia do mês] [mês] [dia da semana] [ano]")

2. Fixerrate e FixerDelay

A anotação @Scheduled elimina a expressão de Cron e existem outros métodos de configuração, como Retrate e FellDelay. O exemplo a seguir implementa diferentes formas de programação de tarefas de tempo através de diferentes métodos de configuração. O código de exemplo é o seguinte:

 pacote com.power.demo.scheduledTask.simple; importar com.power.demo.util.dateTimeUtil; importar org.springframework.scheduling.annotation.enablesCheduling; import org.springframework.sChedinging.Notation.SchedulEd; Import.mmport; java.util.date;@componente@enablechedulingpublic classe springtaskb { /*fixo: execute novamente 5 segundos após o último ponto do tempo* / @scheduled (fixorate = 5000) public void timerfixedrate () {Try {thread {thread (100000); } catch (Exceção e) {e.printStackTrace (); } System.out.println (String.Format ("(FIRlRATE) Hora atual: %s", DateTimeutil.fmtdate (new Date ()))); } /*FILLDELAY: Execute 5 segundos após o último ponto do tempo de execução* / @scheduled (fixolay = 5000) public void timerfixedDelay () {try {thread.sleep (100); } catch (Exceção e) {e.printStackTrace (); } System.out.println (String.Format ("(FILLDELAY) Hora atual: %S", DateTimeUtil.fmtdate (new Date ()))); } /*Executar após o primeiro atraso é de 2 segundos e, em seguida, execute -o a cada 5 segundos de acordo com a regra fixo* / @scheduled (InitialDelay = 2000, fixolay = 5000) public void timerinitDelay () {try {thread.sleep (100); } catch (Exceção e) {e.printStackTrace (); } System.out.println (string.format ("(initDelay) tempo atual: %s", dateTimeutil.fmtdate (new Date ()))); }} Springtaskb

Observe as principais diferenças:

@Scheduled(fixedRate = 5000) : Execute novamente 5 segundos após o último ponto de execução do tempo

@Scheduled(fixedDelay = 5000) : execute novamente 5 segundos após o último ponto do tempo de execução

@Scheduled(initialDelay=2000, fixedDelay=5000) : Execute após o primeiro atraso é de 2 segundos e, em seguida, pressione a regra do FeltonDELAY para executar a cada 5 segundos

Às vezes, muitos projetos precisam ser configurados e executados imediatamente após a configuração das tarefas programadas e o InitialDelay não for necessário.

3 Zona

A anotação @Scheduled também possui uma zona de atributo familiar, indicando o fuso horário. Geralmente, se não estiver escrito, a tarefa de tempo usará o fuso horário padrão do servidor; Se sua tarefa quiser executar em um fuso horário específico e em um momento específico, por exemplo, um sistema multilíngue comum pode executar scripts para atualizar dados regularmente, você pode definir um fuso horário, como a oitava zona leste, que pode ser definida como:

zone = "GMT+8:00"

2. Quartzo

O Quartz é uma das estruturas de agendamento de tarefas de código aberto mais amplamente utilizadas, e muitas empresas implementam seus próprios sistemas de gerenciamento de tarefas de tempo com base nele. O Quartzo fornece dois gatilhos de tarefas de tempo mais usados, como o SimplyTrigger e o Correntador. Este artigo toma o crementador mais utilizado como exemplo.

1. Adicione dependências

 <Depencency> <GrupidId> org.quartz-scheduler </groupid> <ArtifactId> quartz </artifactId> <versão> 2.3.0 </versão> </dependency>

2. Configure expressões cron

Conforme necessário para o código de amostra, adicione a seguinte configuração ao arquivo Application.Properties:

 ## quartzo cronometrou configuração do trabalho job.taska.cron = */3 * * * * job.taskb.cron = */7 * * * * job.taskmail.cron = */5 * * * * *? Job.taskmail.cron = */5 * * * *?

De fato, podemos escrevê -lo no código ou persistir no banco de dados e depois lê -lo sem configurá -lo.

3. Adicione tarefas cronometradas para implementar

Tarefa 1:

 pacote com.power.demo.scheduledTask.quartz; importar com.power.demo.util.dateTimeUtil; importar org.quartz.disallowconcurrentExecution; importação org.quartz.job; import org.quartz.jobexecutionContetTenT; java.util.date; @disallowconcurrentExecutionPublic Classe Quartztaska implementa o trabalho {@Override public void Execute (JobExecutionContext var1) lança JobExecutionException {Try {Thread.Sleep (1); } catch (Exceção e) {e.printStackTrace (); } System.out.println (string.format ("(quartztaska)%s executar a cada 3 segundos, log log", dateTimeutil.fmtdate (new Date ()))); }} Quartztaska

Tarefa 2:

 pacote com.power.demo.scheduledTask.quartz; importar com.power.demo.util.dateTimeUtil; importar org.quartz.disallowconcurrentExecution; importação org.quartz.job; import org.quartz.jobexecutionContetTenT; java.util.date; @disallowconcurrentExecutionPublic Classe QuartztaskB implementa o trabalho {@Override public void Execute (JobExecutionContext var1) lança JobExecutionException {Try {Thread.Sleep (100); } catch (Exceção e) {e.printStackTrace (); } System.out.println (string.format ("(quartztaskb)%s execute a cada 7 segundos, log log", dateTimeutil.fmtdate (new Date ()))); }} Quartztaskb

Enviar oportunamente as tarefas de e -mail:

 pacote com.power.demo.scheduledTask.quartz; import com.power.demo.service.constract.mailservice; importar com.power.demo.util.dateTimeUtilil; importação.Power.Demo.util.PowerLog; importArg.joda.time.matetime; importime.demo.util.powerLog; importArg.joda.time.matetime; importime; import.demo.util.powerLog; importArg.joda.time.matetime; importime; importime.demo.util.powerlog; org.quartz.job; importar org.quartz.jobexecutionContext; importar org.quartz.jobexecutionException; importar org.springframework.beans.factory.annotation.aUTOWIRED; MailService; @Override public void Execute (JobExecutionContext var1) lança JobExecutionException {System.out.println (String.Format ("(MailSendTask)%S Send Mail tente {//thread.sleep(1); DATETIME DTNOW = new DateTime (new Date ()); Data starttime = dtnow.Minusmonths (1) .todate (); // Um mês atrás Data Endtime = dtnow.plusDays (1) .todate (); MailService.AUTOSEND (StartTime, Endtime); PowerLogger.Info (String.Format ("Enviar e -mail, horário de início: %s, horário de término: %s", DateTimeutil.fmtdate (starttime), DateTimeutil.fmtdate (EndTime))); } catch (Exceção e) {e.printStackTrace (); PowerLogger.info (String.Format ("Enviar e -mail, exceção ocorre: %s, tempo de término: %s", e)); }}} MailSendTask

A implementação de tarefas parece muito simples, apenas herdar a interface de trabalho do quartzo e reescrever o método Execute.

4. Integrar tarefas de tempo de quartzo

Como fazer a Spring reconhecer automaticamente a inicialização das instâncias de tarefas de tempo de quartzo? Isso requer referência aos grãos gerenciados da primavera, expondo os grãos necessários aos recipientes de mola e injetando -os automaticamente definindo a fábrica de empregos.

Primeiro, adicione a aula de fábrica de empregos injetados na primavera:

 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; importar org.springframework.scheduling.quartz.springbeanjobfactory; classe final public AutoToireBeanJobFactory estende SpringBeanJobFactory implementando o aplicativo; /*** O Spring fornece um mecanismo que permite obter o ApplicationContext, ou seja, interface ApplicationContexTAWare* para uma classe que implementa a interface ApplicationContexTAWe, a Spring o instanciará e chamará sua* public voidSetApplicationContext (ApplicationContext ApplicationContext) lança Beansexception; Interface, * passe o contexto ao qual o feijão pertence. **/ @Override public void setApplicationContext (Final ApplicationContext Context) {beanFactory = context.GetaTowirecApableBeanFactory (); } @Override Objeto protegido CreateJobInstance (Final TriggerFiredBundle Bundle) lança exceção {Final Object Job = super.CreateJobInstance (pacote); beanfactory.autowireBean (Job); trabalho de retorno; }} AutowireBeanJobFactory

Definir quartzconfig:

 package com.power.demo.scheduledtask.quartz.config;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.beans.factory.annotation.Qualifier;import org.springframework.context.annotation.Bean;import org.springframework.context.annotation.configuration; importar org.springframework.scheduling.quartz.crriggerFactoryBean; importação org.springframework.scheduling.Quartz.schedulerFactoryBean; @conCrUnturationPublic ClassClic.SCHARTZ.SCHEDULERFACORDBEAN; @Qualifier ("quartztaskatrigger") privado cRentriggerFactoryBean quartztaskatrigger; @Autowired @qualifier ("quartztaskbtrigger") privado crontriggerFactoryBean quartztaskbtrigger; @Autowired @Qualifier ("MailSendtrigger") Private CrontriggerFactoryBean MailSendtrigger; // O trabalho no quartzo injeta automaticamente o objeto hospedado pelo contêiner da primavera @Bean Public AutoTeReBeanJobFactory AutoWiringspringBeanJOBFactory () {return New AutowireBeanJobFactory (); } @Bean Public SchedulerFactoryBean SchedulerFactoryBean () {SchedulerFactoryBean Scheduler = new SchedulerFactoryBean (); scheduler.setJobFactory (AutowiringsPringBeanJobFactory ()); // Configure a classe de trabalho injetada por Spring // Defina o CrontriggerFactoryBean e defina o acionador de tarefas Scheduler.SetTriggers (quartztaskatriGger.getObject (), quartztaskbtrigger.getObject (), MailSendTrigger.getObject ()); Agendador de retorno; }} Quartzconfig

Em seguida, configure os detalhes do trabalho:

 pacote com.power.demo.scheduledTask.quartz.config; importar com.power.demo.util.configuil; importar com.power.demo.scheduledtask.quartz.mailsendTask; import com.power.demo.scheduedtasktask.quartzArza; com.power.demo.scheduledtask.quartz.quartztaskb; importar com.power.demo.util.configuil; importar org.springframework.context.annotation.bean; importar org.springframework.context.annotation.notation.bean; org.springframework.scheduling.quartz.crentriggerFactoryBean; importar org.springframework.scheduling.quartz.jobdetailfactoryBean; @configurationpublic classe TaskSetting {@Bean (names = "Quartastaska") trabalha JobDetail JobDetailFactoryBean Factory = new JobDetailFactoryBean (); Factory.setJobclass (quartztaska.class); // defina o trabalho de trabalho correspondente.setGroup ("quartztaskGroup"); Factory.SetName ("Quartztaskajob"); Factory.SetDurability (false); Factory.SetDescription ("Tarefa de teste A"); fábrica de retorno; } @Bean (name = "quartztaskatrigger") public crontriggerFactoryBean crontrigGerAfactoryBean () {string cron = configutil.getConfigval (appfield.job_taska_cron); CRontriggerFactoryBean stFactory = new CrontriggerFactoryBean (); // Definir JobDetail stFactory.setJobDetail (JobDetailaFactoryBean (). GetObject ()); stFactory.SetStartDelay (1000); stFactory.SetName ("quartztaskatrigger"); stFactory.setGroup ("quartztaskGroup"); StFactory.Setcronexpression (Cron); retornar stFactory; } @Bean (name = "quartztaskb") public JobDetailFactoryBean JobDetailBFactoryBean () {// Gere JobDetail JobDetailFactoryBean Factory = new JobDetailFactoryBean (); Factory.setJobclass (quartztaskb.class); // defina o trabalho de trabalho correspondente.setGroup ("quartztaskGroup"); Factory.SetName ("quartztaskbjob"); Factory.SetDurability (false); fábrica.SetDescription ("Tarefa de teste B"); fábrica de retorno; } @Bean (name = "quartztaskbtrigger") public crontriggerFactoryBean crontriggerBFactoryBean () {string cron = configutil.getConfigval (appfield.job_taskb_cron); CRontriggerFactoryBean stFactory = new CrontriggerFactoryBean (); // Definir JobDetail stFactory.setJobDetail (JobDetailBFactoryBean (). GetObject ()); stFactory.SetStartDelay (1000); stFactory.SetName ("quartztaskbtrigger"); stFactory.setGroup ("quartztaskGroup"); StFactory.Setcronexpression (Cron); retornar stFactory; } @Bean (name = "MailSendTask") public JobDetailFactoryBean JobDetailMailFactoryBean () {// Gere JobDetail JobDetailFactoryBean Factory = new JobDetailFactoryBean (); Factory.setJobclass (MailSendTask.class); // defina o trabalho de trabalho correspondente.setGroup ("quartztaskGroup"); Factory.SetName ("MailSendTaskJob"); Factory.SetDurability (false); Factory.SetDescription ("MailSendtrigger"); fábrica de retorno; } @Bean (name = "MailSendtrigger") public crontriGgerFactoryBean CrontrigGermailFactoryBean () {String cron = configutil.getConfigval (AppField.job_taskmail_cron); CRontriggerFactoryBean stFactory = new CrontriggerFactoryBean (); // Definir JobDetail stFactory.setJobDetail (JobDetailMailFactoryBean (). GetObject ()); stFactory.SetStartDelay (1000); stFactory.SetName ("MailSendtrigger"); stFactory.setGroup ("quartztaskGroup"); StFactory.Setcronexpression (Cron); retornar stFactory; }} TaskSetting

Por fim, inicie o aplicativo de tarefa de tempo de inicialização da primavera e uma tarefa de tempo completa com base no cronograma de quartzo será implementada.

Neste exemplo de tarefa cronometrada, há um correio cronometrado Enviar Tarefa MailSendTask. O próximo artigo compartilhará o sistema de email simples no aplicativo de inicialização da primavera usando o MongoDB como o meio de armazenamento.

Leitura estendida:

Muitas empresas têm sua própria estrutura de agendamento de tarefas cronometradas. Como integrar o cluster de quartzo na inicialização da primavera para implementar a configuração dinâmica de tarefas cronometradas?

Consulte:

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

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

Resumir

O acima é o conteúdo inteiro deste artigo. Espero que o conteúdo deste artigo tenha certo valor de referência para o estudo ou trabalho de todos. Se você tiver alguma dúvida, pode deixar uma mensagem para se comunicar. Obrigado pelo seu apoio ao wulin.com.