injecter une référence de grain dans un travail de Quartz au printemps?

vous pouvez utiliser ce SpringBeanJobFactory pour autowire automatiquement des objets de quartz en utilisant le ressort:

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 class AutowiringSpringBeanJobFactory extends SpringBeanJobFactory implements
    ApplicationContextAware {

    private transient AutowireCapableBeanFactory beanFactory;

    @Override
    public void setApplicationContext(final ApplicationContext context) {
        beanFactory = context.getAutowireCapableBeanFactory();
    }

    @Override
    protected Object createJobInstance(final TriggerFiredBundle bundle) throws Exception {
        final Object job = super.createJobInstance(bundle);
        beanFactory.autowireBean(job);
        return job;
    }
}

ensuite, attachez-le à votre SchedulerBean (dans ce cas, avec Java-config):

@Bean
public SchedulerFactoryBean quartzScheduler() {
    SchedulerFactoryBean quartzScheduler = new SchedulerFactoryBean();

    ...

    AutowiringSpringBeanJobFactory jobFactory = new AutowiringSpringBeanJobFactory();
    jobFactory.setApplicationContext(applicationContext);
    quartzScheduler.setJobFactory(jobFactory);

    ...

    return quartzScheduler;
}

travaillant pour moi, en utilisant le ressort-3.2.1 et le quartz-2.1.6.

consultez la gist ici .

j'ai trouvé la solution dans ce post de blog

je viens de mettre SpringBeanAutowiringSupport.processInjectionBasedOnCurrentContext(this); comme première ligne de ma méthode Job.execute(JobExecutionContext context) .

le même problème a été résolu dans LINK :

je pourrais trouver une autre option de post sur le forum de ressort que vous pouvez passer une référence au contexte D'application de ressort via le SchedulerFactoryBean. Comme l'exemple ci-dessous:

<bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
<propertyy name="triggers">
    <list>
        <ref bean="simpleTrigger"/>
            </list>
    </property>
    <property name="applicationContextSchedulerContextKey">
        <value>applicationContext</value>
</property>

Ensuite, en utilisant le code ci-dessous dans votre classe de travail, vous pouvez obtenir l'applicationContext et obtenir ce que vous voulez bean.

appCtx = (ApplicationContext)context.getScheduler().getContext().get("applicationContextSchedulerContextKey");

J'espère que ça aidera. Vous peut obtenir plus d'information à partir de Mark Mclaren'sblog

vous avez raison dans votre hypothèse sur le printemps vs. Quartz instantiating la classe. Cependant, le printemps fournit quelques classes qui vous permettent de faire une injection primitive de dépendance dans le Quartz. Découvrez SchedulerFactoryBean.setJobFactory () avec le Springbeanjfactory . Essentiellement, en utilisant le SpringBeanJobFactory, vous activez l'injection de dépendance sur toutes les propriétés de travail, mais seulement pour les valeurs qui sont dans le Quartz planificateur de contexte ou la les données de la tâche de la carte . Je ne sais pas quels sont tous les styles QU'il supporte (constructeur, annotation, setter...) mais je sais qu'il supporte l'injection de setter.

pour tous ceux qui veulent l'essayer dans l'avenir.

org.springframework.programmer.quartz.JobDetailBean Fournitures carte des objets et ces objets peuvent être des haricots de printemps.

définit smth comme

<bean name="myJobDetail" class="org.springframework.scheduling.quartz.JobDetailBean">
    <property name="jobClass"
        value="my.cool.class.myCoolJob" />
    <property name="jobDataAsMap">
        <map>
            <entry key="myBean" value-ref="myBean" />
        </map>
    </property>
</bean>

et puis, à l'intérieur

public void executeInternal(JobExecutionContext context)

appel myBean = (myBean) context.getMergedJobDataMap().get("myBean"); et vous tous ensemble. Je sais, il semble laid, mais comme une solution, elle fonctionne

ApplicationContext springContext =

WebApplicationContextUtils.getWebApplicationContext(ContextLoaderListener .getCurrentWebApplicationContext().getServletContext());

Bean bean = (Bean) springContext.getBean("beanName");

bean.method();

Merci, Rippon! J'ai finalement obtenu ce travail aussi, après beaucoup de luttes, et ma solution est très proche de ce que vous avez suggéré! La clé était de faire mon propre travail pour étendre QuartzJobBean, et d'utiliser le schedulerContextAsMap.

je me suis enfui sans spécifier la propriété applicationContextSchedulerContextkey - elle a fonctionné sans elle pour moi.

Pour le bénéfice des autres, voici la configuration finale qui a fonctionné pour moi:

    <bean id="quartzScheduler"  class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
        <property name="configLocation" value="classpath:spring/quartz.properties"/>
        <property name="jobFactory">
            <bean  class="org.springframework.scheduling.quartz.SpringBeanJobFactory" />
        </property>
        <property name="schedulerContextAsMap">
            <map>
                <entry key="mailService" value-ref="mailService" />
            </map>
        </property>
</bean>
<bean id="jobTriggerFactory"
      class="org.springframework.beans.factory.config.ObjectFactoryCreatingFactoryBean">
    <property name="targetBeanName">
        <idref local="jobTrigger" />
    </property>
</bean>
<bean id="jobTrigger"   class="org.springframework.scheduling.quartz.SimpleTriggerBean"
    scope="prototype">
      <property name="group" value="myJobs" />
      <property name="description" value="myDescription" />
      <property name="repeatCount" value="0" />
</bean>

<bean id="jobDetailFactory"
      class="org.springframework.beans.factory.config.ObjectFactoryCreatingFactoryBean">
    <property name="targetBeanName">
        <idref local="jobDetail" />
    </property>
</bean>

<bean id="jobDetail" class="org.springframework.scheduling.quartz.JobDetailBean"
scope="prototype">
<property name="jobClass" value="com.cambridgedata.notifications.EMailJob" />
<property name="volatility" value="false" />
<property name="durability" value="false" />
<property name="requestsRecovery" value="true" />
</bean> 
<bean id="notificationScheduler"   class="com.cambridgedata.notifications.NotificationScheduler">
    <constructor-arg ref="quartzScheduler" />
    <constructor-arg ref="jobDetailFactory" />
    <constructor-arg ref="jobTriggerFactory" />
</bean>

Avis que l '"mailService" bean est mon propre service de haricots, géré par Spring. J'ai pu accéder dans mon Travail comme suit:

    public void executeInternal(JobExecutionContext context)
    throws JobExecutionException {

    logger.info("EMailJob started ...");
    ....
    SchedulerContext schedulerContext = null;
    try {
        schedulerContext = context.getScheduler().getContext();
    } catch (SchedulerException e1) {
        e1.printStackTrace();
    }
    MailService mailService = (MailService)schedulerContext.get("mailService");
    ....

et cette configuration m'a également permis de programmer dynamiquement des travaux, en utilisant des usines pour obtenir des déclencheurs et des détails et en réglant les paramètres requis sur eux de manière programmatique:

    public NotificationScheduler(final Scheduler scheduler,
        final ObjectFactory<JobDetail> jobDetailFactory,
        final ObjectFactory<SimpleTrigger> jobTriggerFactory) {
    this.scheduler = scheduler;
    this.jobDetailFactory = jobDetailFactory;
    this.jobTriggerFactory = jobTriggerFactory;
           ...
        // create a trigger
        SimpleTrigger trigger = jobTriggerFactory.getObject();
        trigger.setRepeatInterval(0L);
    trigger.setStartTime(new Date());

    // create job details
    JobDetail emailJob = jobDetailFactory.getObject();

    emailJob.setName("new name");
    emailJob.setGroup("immediateEmailsGroup");
            ...

Merci encore à tous ceux qui ont aidé,

Marina

voici à quoi ressemble le code avec @Component:

classe principale qui planifie l'emploi:

public class NotificationScheduler {

private SchedulerFactory sf;
private Scheduler scheduler;

@PostConstruct
public void initNotificationScheduler() {
    try {
    sf = new StdSchedulerFactory("spring/quartz.properties");
    scheduler = sf.getScheduler();
    scheduler.start();
            // test out sending a notification at startup, prepare some parameters...
    this.scheduleImmediateNotificationJob(messageParameters, recipients);
        try {
            // wait 20 seconds to show jobs
            logger.info("sleeping...");
            Thread.sleep(40L * 1000L); 
            logger.info("finished sleeping");
           // executing...
        } catch (Exception ignore) {
        }

      } catch (SchedulerException e) {
    e.printStackTrace();
    throw new RuntimeException("NotificationScheduler failed to retrieve a Scheduler instance: ", e);
    }
}


public void scheduleImmediateNotificationJob(){
  try {
    JobKey jobKey = new JobKey("key");
    Date fireTime = DateBuilder.futureDate(delayInSeconds, IntervalUnit.SECOND);
    JobDetail emailJob = JobBuilder.newJob(EMailJob.class)
    .withIdentity(jobKey.toString(), "immediateEmailsGroup")
        .build();

    TriggerKey triggerKey = new TriggerKey("triggerKey");
    SimpleTrigger trigger = (SimpleTrigger) TriggerBuilder.newTrigger() 
        .withIdentity(triggerKey.toString(), "immediateEmailsGroup")
        .startAt(fireTime)
        .build();

    // schedule the job to run
    Date scheduleTime1 = scheduler.scheduleJob(emailJob, trigger);
  } catch (SchedulerException e) {
    logger.error("error scheduling job: " + e.getMessage(), e);
    e.printStackTrace();
      }
}

@PreDestroy
public void cleanup(){
    sf = null;
    try {
        scheduler.shutdown();
    } catch (SchedulerException e) {
        e.printStackTrace();
    }
}

L'EmailJob est le même que dans ma première publication à l'exception de l'annotation @Component:

@Component
public class EMailJob implements Job { 
  @Autowired
  private JavaMailSenderImpl mailSenderImpl;
... }

et le fichier de configuration du ressort a:

...
<context:property-placeholder location="classpath:spring/*.properties" />
<context:spring-configured/>
<context:component-scan base-package="com.mybasepackage">
  <context:exclude-filter expression="org.springframework.stereotype.Controller"
        type="annotation" />
</context:component-scan>
<bean id="mailSenderImpl" class="org.springframework.mail.javamail.JavaMailSenderImpl">
    <property name="host" value="${mail.host}"/>
    <property name="port" value="${mail.port}"/>
    ...
</bean>
<bean id="notificationScheduler" class="com.mybasepackage.notifications.NotificationScheduler">
</bean>

Merci pour toute l'aide!

Marina

une solution simple est de mettre le grain de printemps dans la carte de données de travail et puis récupérer le grain dans la classe de travail, par exemple

// the class sets the configures the MyJob class 
    SchedulerFactory sf = new StdSchedulerFactory();
    Scheduler sched = sf.getScheduler();
    Date startTime = DateBuilder.nextGivenSecondDate(null, 15);
    JobDetail job = newJob(MyJob.class).withIdentity("job1", "group1").build();
    job.getJobDataMap().put("processDataDAO", processDataDAO);

"

 // this is MyJob Class
    ProcessDataDAO processDataDAO = (ProcessDataDAO) jec.getMergedJobDataMap().get("processDataDAO");

Une solution de Hary https://stackoverflow.com/a/37797575/4252764 fonctionne très bien. C'est plus simple, il n'a pas besoin de beaucoup de haricots Spéciaux d'usine, et supporte plusieurs déclencheurs et emplois. Ajoutons simplement que Quartz job peut être fait pour être générique, avec des travaux spécifiques mis en œuvre comme des haricots de printemps réguliers.

public interface BeanJob {
  void executeBeanJob();
}

public class GenericJob implements Job {

  @Override
  public void execute(JobExecutionContext context) throws JobExecutionException {
    JobDataMap dataMap = context.getMergedJobDataMap();
    ((BeanJob)dataMap.get("beanJob")).executeBeanJob();    
  }

}

@Component
public class RealJob implements BeanJob {
  private SomeService service;

  @Autowired
  public RealJob(SomeService service) {
    this.service = service;
  }

  @Override
  public void executeBeanJob() {
      //do do job with service
  }

}

une façon simple de le faire serait de simplement annoter les travaux de Quartz avec @Component annotation, et puis le printemps fera toute la magie DI pour vous, comme il est maintenant reconnu comme un haricot de printemps. J'ai dû faire quelque chose de similaire pour un aspect AspectJ - ce n'était pas un haricot de printemps jusqu'à ce que je l'ai annoté avec le stéréotype de printemps @Component .

assurez-vous de votre

AutowiringSpringBeanJobFactory extends SpringBeanJobFactory 

la dépendance est retirée de

    "org.springframework:spring-context-support:4..."

et non de

    "org.springframework:spring-support:2..."

il voulait que j'utilise

@Override
public Job newJob(TriggerFiredBundle bundle, Scheduler scheduler)

au lieu de

@Override
protected Object createJobInstance(final TriggerFiredBundle bundle)

donc, ne pas avoir obtenu l'instance d'emploi d'autowire.

si vous utilisez déjà Real AspectJ dans votre projet, alors vous pouvez annoter la classe job bean avec @Configurable . Puis le ressort injectera dans cette classe, même s'il est construit via new

j'ai fait face au problème similiar et en suis sorti avec l'approche suivante:

<!-- Quartz Job -->
<bean name="JobA" class="org.springframework.scheduling.quartz.JobDetailFactoryBean">
    <!-- <constructor-arg ref="dao.DAOFramework" /> -->
     <property name="jobDataAsMap">
    <map>
        <entry key="daoBean" value-ref="dao.DAOFramework" />
    </map>
</property>
    <property name="jobClass" value="com.stratasync.jobs.JobA" />
    <property name="durability" value="true"/>
</bean>

dans le code ci-dessus, j'injecte dao.DAOFramework fève dans JobA bean et dans l'intérieur de ExecuteInternal méthode, vous pouvez obtenir injecté bean comme:

  daoFramework = (DAOFramework)context.getMergedJobDataMap().get("daoBean");

j'espère que cela aide! Remercier.

la solution ci-dessus est excellente mais dans mon cas l'injection ne fonctionnait pas. J'ai dû utiliser les propriétés autowireBeanProperties à la place, probablement à cause de la façon dont mon contexte est configuré:

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 class AutowiringSpringBeanJobFactory extends SpringBeanJobFactory implements
ApplicationContextAware {

    private transient AutowireCapableBeanFactory beanFactory;

    @Override
    public void setApplicationContext(final ApplicationContext context) {
        beanFactory = context.getAutowireCapableBeanFactory();
    }

    @Override
    protected Object createJobInstance(final TriggerFiredBundle bundle) throws Exception {
        final Object job = super.createJobInstance(bundle);
        //beanFactory.autowireBean(job);
        beanFactory.autowireBeanProperties(job, AutowireCapableBeanFactory.AUTOWIRE_BY_TYPE, true);
        return job;
    }
}

C'est la bonne réponse /q/inject-bean-reference-into-a-quartz-job-in-spring-5183/"classpath*:my-abc-integration-applicationContext.XML" ); pour (Ressource r : ressources) { createdContext = new GenericApplicationContext(context); Xmlbeandefinitionreader reader = new XmlBeanDefinitionReader(createdContext); int i = reader.loadBeanDefinitions(r); } createdContext.refresh();//important sinon vous obtiendrez des exceptions. beanFactory = createdContext.getautowirecapable beanfactory(); {'} catch (IOException e) { e.printStackTrace(); } } @Remplacer proteged Object createJobInstance(final TriggerFiredBundle bundle)) throws Exception { Objet final de l'emploi = super.créatéjobinance (bundle); beanFactory.autowireBean(job); de retour du travail; } }

vous pouvez ajouter n'importe quel nombre de fichiers de contexte que vous voulez que votre quartz soit conscient.

C'est un poste assez ancien qui est encore utile. Toutes les solutions qui proposent ces deux-là avaient peu de condition qui ne suit pas toutes:

• SpringBeanAutowiringSupport.processInjectionBasedOnCurrentContext(this); cela suppose ou exige qu'il s'agisse d'un projet basé sur le web
• AutowiringSpringBeanJobFactory approche basée mentionnée dans la réponse précédente est très utile, mais la réponse est spécifique à ceux qui n'utilisent pas pur quartz api vanille, mais plutôt Spring envelopper pour le quartz de faire le de même.

si vous voulez rester avec L'implémentation Pure Quartz pour la planification(Quartz avec des capacités D'Autowiring avec ressort), j'ai été en mesure de le faire comme suit:

je cherchais à le faire quartz way autant que possible et donc peu de hack se révèle utile.

 public final class AutowiringSpringBeanJobFactory extends SpringBeanJobFactory{

    private AutowireCapableBeanFactory beanFactory;

    public AutowiringSpringBeanJobFactory(final ApplicationContext applicationContext){
        beanFactory = applicationContext.getAutowireCapableBeanFactory();
    }

    @Override
    protected Object createJobInstance(final TriggerFiredBundle bundle) throws Exception {
        final Object job = super.createJobInstance(bundle);
        beanFactory.autowireBean(job);
        beanFactory.initializeBean(job, job.getClass().getName());
        return job;
    }
}


@Configuration
public class SchedulerConfig {   
    @Autowired private ApplicationContext applicationContext;

    @Bean
    public AutowiringSpringBeanJobFactory getAutowiringSpringBeanJobFactory(){
        return new AutowiringSpringBeanJobFactory(applicationContext);
    }
}


private void initializeAndStartScheduler(final Properties quartzProperties)
            throws SchedulerException {
        //schedulerFactory.initialize(quartzProperties);
        Scheduler quartzScheduler = schedulerFactory.getScheduler();

        //Below one is the key here. Use the spring autowire capable job factory and inject here
        quartzScheduler.setJobFactory(autowiringSpringBeanJobFactory);
        quartzScheduler.start();
    }

quartzScheduler.setJobFactory(autowiringSpringBeanJobFactory); nous donne un exemple d'emploi auto-entretenu. Puisque AutowiringSpringBeanJobFactory implemente implicitement un JobFactory , nous maintenant activé une solution auto-wireable. Espérons que cette aide!

toutes ces solutions ci-dessus ne fonctionne pas pour moi avec Spring 5 et Hibernate 5 et Quartz 2.2.3 quand je veux appeler les méthodes transactionnelles!

j'ai donc mis en œuvre cette solution qui démarre automatiquement l'ordonnanceur et déclenche les travaux. J'ai trouvé beaucoup de ce code à dzone . Parce que je n'ai pas besoin de créer des triggers et des jobs de manière dynamique, je voulais que les triggers statiques soient prédéfinis via la Configuration du ressort et que seuls les jobs soient prédéfinis. exposé comme éléments de ressorts.

ma configuration de base ressemble à ceci

@Configuration
public class QuartzConfiguration {

  @Autowired
  ApplicationContext applicationContext;

  @Bean
  public SchedulerFactoryBean scheduler(@Autowired JobFactory jobFactory) throws IOException {
    SchedulerFactoryBean sfb = new SchedulerFactoryBean();

    sfb.setOverwriteExistingJobs(true);
    sfb.setAutoStartup(true);
    sfb.setJobFactory(jobFactory);

    Trigger[] triggers = new Trigger[] {
        cronTriggerTest().getObject()
    };
    sfb.setTriggers(triggers);
    return sfb;
  }

  @Bean
  public JobFactory cronJobFactory() {
    AutowiringSpringBeanJobFactory jobFactory = new AutowiringSpringBeanJobFactory();
    jobFactory.setApplicationContext(applicationContext);
    return jobFactory;
  }

  @Bean 
  public CronTriggerFactoryBean cronTriggerTest() {
    CronTriggerFactoryBean tfb = new CronTriggerFactoryBean();
    tfb.setCronExpression("0 * * ? * * *");

    JobDetail jobDetail = JobBuilder.newJob(CronTest.class)
                            .withIdentity("Testjob")
                            .build()
                            ;

    tfb.setJobDetail(jobDetail);
    return tfb;
  }

}

comme vous pouvez le voir, vous avez le scheduler et un déclencheur de test simple qui est défini par une expression cron. Vous pouvez évidemment choisir n'importe quelle expression de planification que vous aimez. Vous avez alors besoin de L'Autowiringspringbeanjfactory qui va comme ceci

public final class AutowiringSpringBeanJobFactory extends SpringBeanJobFactory implements ApplicationContextAware {

  @Autowired
  private ApplicationContext applicationContext;

  private SchedulerContext schedulerContext;

  @Override
  public void setApplicationContext(final ApplicationContext context) {
    this.applicationContext = context;
  }


  @Override
  protected Object createJobInstance(final TriggerFiredBundle bundle) throws Exception {
    Job job = applicationContext.getBean(bundle.getJobDetail().getJobClass());
    BeanWrapper bw = PropertyAccessorFactory.forBeanPropertyAccess(job);

    MutablePropertyValues pvs = new MutablePropertyValues();
    pvs.addPropertyValues(bundle.getJobDetail().getJobDataMap());
    pvs.addPropertyValues(bundle.getTrigger().getJobDataMap());

    if (this.schedulerContext != null)
    {
        pvs.addPropertyValues(this.schedulerContext);
    }
    bw.setPropertyValues(pvs, true);

    return job;
  }  

  public void setSchedulerContext(SchedulerContext schedulerContext) {
    this.schedulerContext = schedulerContext;
    super.setSchedulerContext(schedulerContext);
  }

}

ici vous connectez votre contexte normal d'application et votre travail ensemble. Ce est l'écart important parce que normalement Quartz commence ses threads d'ouvrier qui n'ont aucune connexion à votre contexte d'application. C'est la raison pour laquelle vous ne pouvez pas exécuter des méhtodes Transactionnels. La dernière chose qui manque c'est un travail. Il peut ressembler à cela

@Component
public class CronTest implements Job {

  @Autowired
  private MyService s;

  public CronTest() {
  }

  @Override
  public void execute(JobExecutionContext context) throws JobExecutionException {
    s.execute();
  }

}

ce n'est pas une solution parfaite parce que vous une classe supplémentaire que pour appeler votre méthode de service. Mais, cependant, il fonctionne.