使用父类构造器设置基于构造函数的弹簧Quartz

Question

我有一个春季启动项目，我想在某些时间使用Quartz来运行某些作业。我有这个类的布局：

abstract public class AbstractFoo {
    protected final FooB fooB;
    public AbstractFoo(FooB fooB) {
        this.fooB = fooB;
    }
}
@Service
public class SomeJob extends AbstractFoo implements Job {
    public SomeJob(FooB fooB) {
        super(fooB);
    }
    @Override
    public void execute(final JobExecutionContext context) throws JobExecutionException {
        //do stuff
    }
}

但是，当我运行此作业时，我会收到以下错误：

2017-12-06 14:18:01,383  ERROR --- [quartz-jobs] org.quartz.core.ErrorLogger                                                                : An error occured instantiating job to be executed. job= 'jobGroup.someJob' 
org.quartz.SchedulerException: Job instantiation failed
    at org.springframework.scheduling.quartz.AdaptableJobFactory.newJob(AdaptableJobFactory.java:45)
    at org.quartz.core.JobRunShell.initialize(JobRunShell.java:127)
    at org.quartz.core.QuartzSchedulerThread.run(QuartzSchedulerThread.java:375)
Caused by: java.lang.InstantiationException: com.jobs.SomeJob
    at java.lang.Class.newInstance(Class.java:427)
    at org.springframework.scheduling.quartz.AdaptableJobFactory.createJobInstance(AdaptableJobFactory.java:58)
    at org.springframework.scheduling.quartz.SpringBeanJobFactory.createJobInstance(SpringBeanJobFactory.java:74)
    at com.config.AutowiringSpringBeanJobFactory.createJobInstance(AutowiringSpringBeanJobFactory.java:27)
    at org.springframework.scheduling.quartz.AdaptableJobFactory.newJob(AdaptableJobFactory.java:41)
    ... 2 common frames omitted
Caused by: java.lang.NoSuchMethodException: com.jobs.SomeJob.<init>()
    at java.lang.Class.getConstructor0(Class.java:3082)
    at java.lang.Class.newInstance(Class.java:412)
    ... 6 common frames omitted

我已经有一个像这样的自动工厂：

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;
    }
}

这是我的石英配置：

@Configuration
public class QuartzConfig {
    @Autowired
    private DataSource dataSource;
    @Autowired
    private PlatformTransactionManager transactionManager;
    @Autowired
    private ApplicationContext applicationContext;
    @Bean
    public SchedulerFactoryBean quartzScheduler() {
        SchedulerFactoryBean quartzScheduler = new SchedulerFactoryBean();
        quartzScheduler.setDataSource(dataSource);
        quartzScheduler.setTransactionManager(transactionManager);
        quartzScheduler.setOverwriteExistingJobs(true);
        quartzScheduler.setSchedulerName("quartz-jobs");
        AutowiringSpringBeanJobFactory jobFactory = new AutowiringSpringBeanJobFactory();
        jobFactory.setApplicationContext(applicationContext);
        quartzScheduler.setJobFactory(jobFactory);
        quartzScheduler.setQuartzProperties(quartzProperties());
        Trigger[] triggers = {someJobTrigger().getObject();
        quartzScheduler.setTriggers(triggers);
        return quartzScheduler;
    }
    @Bean
    public CronTriggerFactoryBean someJobTrigger() {
        CronTriggerFactoryBean cronTriggerFactoryBean = new CronTriggerFactoryBean();
        cronTriggerFactoryBean.setJobDetail(someJob().getObject());
        cronTriggerFactoryBean.setCronExpression(cronExp);
        cronTriggerFactoryBean.setGroup(someGroup);
        return cronTriggerFactoryBean;
    }
    @Bean
    public JobDetailFactoryBean someJob() {
        JobDetailFactoryBean jobDetailFactory = new JobDetailFactoryBean();
        jobDetailFactory.setJobClass(SomeJob.class);
        jobDetailFactory.setGroup(someGroup);
        jobDetailFactory.setDurability(true);
        return jobDetailFactory;
    }
    @Bean
    public Properties quartzProperties() {
        PropertiesFactoryBean propertiesFactoryBean = new PropertiesFactoryBean();
        propertiesFactoryBean.setLocation(new ClassPathResource("/quartz.properties"));
        Properties properties = null;
        try {
            propertiesFactoryBean.afterPropertiesSet();
            properties = propertiesFactoryBean.getObject();
        } catch (IOException e) {
        }
        return properties;
    }
}

如何通过构造函数使石英连接到适当的依赖项？

Answer 1

文档中所述：

这种行为的后果之一是工作必须 有一个无折磨的构造函数（使用默认的JobFactory时 实施）。

您本质上使用默认的JobFactory并添加了自动功能。我从个人测试中发现的是，AutoWiring无法与构造函数注入一起使用。另外，不要用春季注释（组件，服务，E.C.T）标记您的工作，因为它没有效果。

要解决您的问题，请重构工作以使用默认的构造函数和带有现场注入的自动依赖性（也许Setter注入也可能起作用）。

abstract public class AbstractFoo {
    @Autowired
    protected FooB fooB;
}
public class SomeJob extends AbstractFoo implements Job {
    @Override
    public void execute(final JobExecutionContext context) throws JobExecutionException {
        //do stuff
    }
}

Answer 2

我刚刚在此处发布了一个带有自动功能的普通石英的答案。但是，请注意，您需要拥有一个no-args构造函数（在您的情况下同时使用no-args和arg构造函数）。Quartz使用类名来实例化实例，因此，您的构造函数与参数无法工作。

如果您仍在处理相同的问题，请尝试我的方法，可以在其中自动导线所需的依赖关系，而不是通过super(foo);

进行。

https://stackoverflow.com/a/49316580/2931410

Answer 3

当类不包含默认构造函数时，此问题就会发生。

示例： yourjob扩展了Quartzjobbean ，然后类应包含默认构造函数。如果使用Lombok，添加 @component adnotation和 @noargsconstructor 。@Autowired