Spring boot框架整合quartz,job类中依赖注入报空指针问题

  之前做的一个项目用到quartz框架进行定时任务的开发。由于定时任务的job类中需要调用其他service的方法,所以必须注入需要的bean。但是在运行项目的时候发现,job类中的依赖注入会报空指针异常。于是从网上查了相关资料,以解决这个问题。  

    quartz有三个核心概念:调度器、任务和触发器。三者关系是,调度器负责调度各个任务,到了某个时刻或者过了一定时间,触发器触动了,特定任务便启动执行。概念相对应的类和接口有:

        1)Job:表示一个工作,要执行的具体内容。此接口中只有一个方法
void execute(JobExecutionContext context)
   2)JobDetail:描述任务的相关情况,包括配置任务执行的类和方法。 Job是这个可执行程调度程序所要执行的内容,另外JobDetail还包含了这个任务调度的方案和策略。
  3)Trigger:描述出发Job执行的时间触发规则。 代表一个调度参数的配置,什么时候去调。有SimpleTrigger和CronTrigger两个子类代表两种方式,一种是每隔多少分钟小时执行,则用SimpleTrigger;另一种是日历相关的重复时间间隔,如每天凌晨,每周星期一运行的话,通过Cron表达式便可定义出复杂的调度方案。
   4)Scheduler:代表一个Quartz的独立运行容器,Trigger和JobDetail要注册到Scheduler中才会生效,也就是让调度器知道有哪些触发器和任务,才能进行按规则进行调度任务 ,一个调度容器中可以注册多个JobDetail和Trigger。当Trigger与JobDetail组合,就可以被Scheduler容器调度了 

    在quartz框架中,Job 是通过反射出来的实例,不受spring的管理。Scheduler现在交给Spring生成,在Spirng-context-support  jar包下org.springframework.scheduling.quartz包中有个SpringBeanJobFactory的类,job实例通过该类的createJobInstance方法创建。根据Scheduler context、job data map and trigger data map填充其属性。但是创建的job实例并没被spring管理,这就需要我们自定义一个类将创建的job添加到applicationContext中,该类需要继承SpringBeanJobFactory,并实现ApplicationContextAware接口。

    ApplicationContextAware接口的作用:Spring容器会检测容器中的所有Bean,如果发现某个Bean实现了ApplicationContextAware接口,Spring容器会在创建该Bean之后,自动调用该Bean的setApplicationContextAware()方法,调用该方法时,会将容器本身作为参数传给该方法——该方法中的实现部分将Spring传入的参数(容器本身)赋给该类对象的applicationContext实例变量,因此接下来可以通过该applicationContext实例变量来访问容器本身。

    重写SpringBeanJobFactory类中的createJobInstance方法,将创建的job实例添加到applicationContext中,交给spring管理。

代码如下:

public final class AutowiringSpringBeanJobFactory extends SpringBeanJobFactory implements
        ApplicationContextAware {

    private transient AutowireCapableBeanFactory autowireCapablebeanFactory;

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

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

再将AutowiringSpringBeanJobFactory交给spring管理,job类中依赖注入空指针问题就解决了

@Configuration
public class SchedulerConfig {
    
    @Bean
    public JobFactory jobFactory(ApplicationContext applicationContext)
    {
        AutowiringSpringBeanJobFactory jobFactory = new AutowiringSpringBeanJobFactory();
        jobFactory.setApplicationContext(applicationContext);
        return jobFactory;
    }

    @Bean
    public SchedulerFactoryBean schedulerFactoryBean(JobFactory jobFactory) throws Exception {
        SchedulerFactoryBean factory = new SchedulerFactoryBean();
        factory.setOverwriteExistingJobs(true);
        factory.setJobFactory(jobFactory);
        factory.setQuartzProperties(quartzProperties());
        factory.afterPropertiesSet();
        return factory;
    }

    @Bean
    public Properties quartzProperties() throws IOException {
        PropertiesFactoryBean propertiesFactoryBean = new PropertiesFactoryBean();
        propertiesFactoryBean.setLocation(new ClassPathResource("/quartz.properties"));
        propertiesFactoryBean.afterPropertiesSet();
        return propertiesFactoryBean.getObject();
    }

}


**本人能力有限,如果有什么错误还望大家及时纠正,一定会虚心接受,共同进步。
  • 0
    点赞
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
### 回答1: Spring Boot可以很方便地整合Quartz,只需要在pom.xml添加相关依赖,然后在配置文件配置Quartz相关属性即可。 具体步骤如下: 1. 在pom.xml添加Quartz依赖: ``` <dependency> <groupId>org.quartz-scheduler</groupId> <artifactId>quartz</artifactId> <version>2.3.2</version> </dependency> ``` 2. 在配置文件配置Quartz相关属性: ``` spring.quartz.job-store-type=jdbc spring.quartz.jdbc.initialize-schema=always spring.quartz.properties.org.quartz.scheduler.instanceName=myScheduler spring.quartz.properties.org.quartz.scheduler.instanceId=AUTO spring.quartz.properties.org.quartz.jobStore.class=org.quartz.impl.jdbcjobstore.JobStoreTX spring.quartz.properties.org.quartz.jobStore.driverDelegateClass=org.quartz.impl.jdbcjobstore.StdJDBCDelegate spring.quartz.properties.org.quartz.jobStore.dataSource=myDS spring.quartz.properties.org.quartz.jobStore.tablePrefix=QRTZ_ spring.quartz.properties.org.quartz.dataSource.myDS.driverClassName=com.mysql.jdbc.Driver spring.quartz.properties.org.quartz.dataSource.myDS.URL=jdbc:mysql://localhost:3306/quartz?useUnicode=true&characterEncoding=utf-8&useSSL=false spring.quartz.properties.org.quartz.dataSource.myDS.user=root spring.quartz.properties.org.quartz.dataSource.myDS.password=root ``` 3. 创建Job类和Trigger类: ``` @Component public class MyJob implements Job { @Override public void execute(JobExecutionContext context) throws JobExecutionException { System.out.println("Hello, Quartz!"); } } @Configuration public class QuartzConfig { @Bean public JobDetail myJobDetail() { return JobBuilder.newJob(MyJob.class) .withIdentity("myJob") .storeDurably() .build(); } @Bean public Trigger myTrigger() { return TriggerBuilder.newTrigger() .forJob(myJobDetail()) .withIdentity("myTrigger") .withSchedule(CronScheduleBuilder.cronSchedule("/5 * * * * ?")) .build(); } } ``` 4. 在启动类中注入SchedulerFactoryBean并启动Quartz: ``` @SpringBootApplication public class Application { public static void main(String[] args) { SpringApplication.run(Application.class, args); } @Autowired private SchedulerFactoryBean schedulerFactoryBean; @PostConstruct public void startQuartz() throws SchedulerException { schedulerFactoryBean.getScheduler().scheduleJob(quartzConfig.myJobDetail(), quartzConfig.myTrigger()); } } ``` 这样就完成了Spring Boot整合Quartz的配置。在启动应用程序时,Quartz会自动创建表并启动定时任务。 ### 回答2: Spring Boot是基于Spring Framework的快速应用开发框架,而Quartz是一个任务调度框架,可以帮助我们定义和执行各种类型的后台作业。本文将为你介绍如何使用Spring Boot整合Quartz框架。 1. 添加依赖 在Spring Boot使用Quartz需要添加以下依赖: ``` <dependency> <groupId>org.quartz-scheduler</groupId> <artifactId>quartz</artifactId> <version>2.3.0</version> </dependency> <dependency> <groupId>org.quartz-scheduler</groupId> <artifactId>quartz-jobs</artifactId> <version>2.3.0</version> </dependency> ``` 2. 配置JobQuartzJob是需要执行的任务,我们需要定义一个类来实现这个Job。 ``` public class MyJob implements Job { @Override public void execute(JobExecutionContext context) throws JobExecutionException { // 任务逻辑 } } ``` 3. 配置Trigger 在Quartz,Trigger用于定义任务执行的时间和频率。 ``` public class MyTrigger { public Trigger getTrigger() { return TriggerBuilder.newTrigger() .withIdentity("myTrigger", "group1") .withSchedule(CronScheduleBuilder.cronSchedule("0/5 * * * * ?")) .forJob("myJob", "group1") .build(); } } ``` 在上面的代码,我们使用Cron表达式来定义Job的执行时间。 4. 配置Scheduler 在Quartz,Scheduler是最核心的部分,它负责管理所有的Job和Trigger,并按照预定的时间执行任务。 ``` @Configuration public class SchedulerConfig { @Autowired private ApplicationContext applicationContext; @Bean public SchedulerFactoryBean schedulerFactoryBean() throws IOException { SchedulerFactoryBean factory = new SchedulerFactoryBean(); factory.setQuartzProperties(quartzProperties()); factory.setJobFactory(springBeanJobFactory()); return factory; } @Bean public Properties quartzProperties() throws IOException { PropertiesFactoryBean propertiesFactoryBean = new PropertiesFactoryBean(); propertiesFactoryBean.setLocation(new ClassPathResource("/quartz.properties")); propertiesFactoryBean.afterPropertiesSet(); return propertiesFactoryBean.getObject(); } @Bean public SpringBeanJobFactory springBeanJobFactory() { AutowiringSpringBeanJobFactory jobFactory = new AutowiringSpringBeanJobFactory(); jobFactory.setApplicationContext(applicationContext); return jobFactory; } @Bean public Scheduler scheduler() throws IOException { return schedulerFactoryBean().getScheduler(); } @Bean public JobDetail myJobDetail() { return JobBuilder.newJob(MyJob.class) .withIdentity("myJob", "group1") .storeDurably() .build(); } @Bean public Trigger myTrigger() { return new MyTrigger().getTrigger(); } @PostConstruct public void init() throws SchedulerException, IOException { scheduler().addJob(myJobDetail(), true); scheduler().scheduleJob(myTrigger()); scheduler().start(); } } ``` 在上面的代码,我们创建了一个SchedulerFactoryBean用于创建Scheduler实例,并在配置类中创建了多个Bean,包括JobDetail、Trigger和自定义的SpringBeanJobFactory。 最后,在@PostConstruct注解下,我们将Job和Trigger添加到Scheduler实例,并启动Scheduler开始任务调度。 5. 编写Quartz.properties文件 在resources目录下创建quartz.properties文件,用于配置Quartz的一些属性。 ``` org.quartz.scheduler.instanceName = MyScheduler org.quartz.threadPool.threadCount = 3 org.quartz.jobStore.class = org.quartz.impl.jdbcjobstore.JobStoreTX org.quartz.jobStore.driverDelegateClass = org.quartz.impl.jdbcjobstore.StdJDBCDelegate org.quartz.jobStore.dataSource = myDS org.quartz.jobStore.tablePrefix = QRTZ_ org.quartz.dataSource.myDS.driver = com.mysql.jdbc.Driver org.quartz.dataSource.myDS.URL = jdbc:mysql://localhost:3306/mydb org.quartz.dataSource.myDS.user = myuser org.quartz.dataSource.myDS.password = mypassword org.quartz.dataSource.myDS.maxConnections = 10 ``` 以上就是使用Spring Boot整合Quartz框架的全部步骤,通过以上步骤,我们可以轻松地创建和调度各种类型的后台任务。 ### 回答3: Spring Boot 是一个基于 Spring 框架的快速开发框架,使得构建Spring应用程序非常容易。Quartz 是一个用于作业调度的开源框架,可以通过定义任务和调度器来实现任务的自动化调度。Spring BootQuartz 框架整合,则可以帮助开发人员更加便捷地实现任务调度。 Spring Boot整合Quartz的步骤如下: 1.在 pom.xml 添加 Quartz 的依赖: ```xml <dependency> <groupId>org.quartz-scheduler</groupId> <artifactId>quartz</artifactId> <version>2.3.0</version> </dependency> ``` 2.创建一个 Job 类,在该类中实现具体要执行的任务逻辑,并继承 org.quartz.Job 接口: ```java public class HelloWorldJob implements Job{ public void execute(JobExecutionContext context) throws JobExecutionException { System.out.println("Hello World."); } } ``` 3.在配置文件添加 quartz 相关的配置,例如在 application.properties 文件添加如下配置: ``` spring.quartz.job-store-type=jdbc spring.datasource.driver-class-name=com.mysql.jdbc.Driver spring.datasource.url=jdbc:mysql://localhost:3306/test spring.datasource.username=root spring.datasource.password=123456 spring.quartz.jdbc.initialize-schema=always ``` 4.创建 SchedulerFactoryBean 类,用于创建调度器,并将 Job 注册到调度器: ```java @Configuration public class QuartzConfig { @Autowired private DataSource dataSource; @Bean public JobDetail jobDetail() { return JobBuilder.newJob(HelloWorldJob.class) .withIdentity("helloJob") .storeDurably() .build(); } @Bean public Trigger trigger() { SimpleScheduleBuilder scheduleBuilder = SimpleScheduleBuilder.simpleSchedule() .withIntervalInSeconds(10) .repeatForever(); return TriggerBuilder.newTrigger() .forJob(jobDetail()) .withIdentity("helloTrigger") .withSchedule(scheduleBuilder) .build(); } @Bean public SchedulerFactoryBean schedulerFactory() { SchedulerFactoryBean schedulerFactoryBean = new SchedulerFactoryBean(); schedulerFactoryBean.setDataSource(dataSource); schedulerFactoryBean.setJobDetails(jobDetail()); schedulerFactoryBean.setTriggers(trigger()); return schedulerFactoryBean; } } ``` 在 SchedulerFactoryBean 类中,首先创建了一个 JobDetail 类,用于描述 Job 相关的信息。然后,通过调用 TriggerBuilder 类的 newTrigger() 方法创建了一个 trigger,用于描述 Job 调度的策略和时间。最后,通过调用 SchedulerFactoryBean 的 setJobDetails() 方法和 setTriggers() 方法将 Job 和 trigger 注册到调度器。 5.启动应用程序,任务就会开始按照调度器定义的策略自动运行。 总的来说,Spring Boot整合Quartz非常容易,只需添加相应的依赖、编写 Job 类和 SchedulerFactoryBean 类,并在配置文件添加相关的配置即可获得方便的任务调度功能。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值