Quartz的使用（解决quartz的job无法注入spring对象）

最新推荐文章于 2022-06-30 13:10:58 发布
最新推荐文章于 2022-06-30 13:10:58 发布
阅读量270 收藏
点赞数
文章标签： spring boot quartz
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wearenazimdb/article/details/81989611
版权

1、说明：

spring3.1以下的版本必须使用quartz1.x系列，3.1以上的版本才支持quartz 2.x，不然会出错。至于原因，则是spring对于quartz的支持实现org.springframework.scheduling.quartz.CronTriggerBean继承了org.quartz.CronTrigger，在quartz1.x系列中org.quartz.CronTrigger是个类，而在quartz2.x系列中org.quartz.CronTrigger变成了接口，从而造成无法用spring的方式配置quartz的触发器（trigger）。

我使用的quartz版本是2.2.1 。

问题：
原来的Job是Spring自动扫描的，属性可以自动注入，现在换成使用单独的Quartz，属性不能注入了。
2、自定义一个类：

一般情况下，quartz的job中使用autowired注解注入的对象为空，这时候我们就要使用spring-quartz提供的AdaptableJobFactory类。

package com.yj.quartzjob;

import org.quartz.spi.TriggerFiredBundle;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
import org.springframework.scheduling.quartz.AdaptableJobFactory;

public class JobFactory extends AdaptableJobFactory {
@Autowired
private AutowireCapableBeanFactory capableBeanFactory; 

@Override 
protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception {  
    //调用父类的方法  
    Object jobInstance = super.createJobInstance(bundle);  
    //进行注入  
    capableBeanFactory.autowireBean(jobInstance);  
    return jobInstance;  
}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

3、Spring.XML的配置：





1
2
3
4
5

4、简单的任务管理类：

package com.yj.until;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.quartz.CronScheduleBuilder;
import org.quartz.CronTrigger;
import org.quartz.DateBuilder;
import org.quartz.DateBuilder.IntervalUnit;
import org.quartz.Job;
import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.JobExecutionContext;
import org.quartz.JobKey;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SimpleScheduleBuilder;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.quartz.TriggerKey;
import org.quartz.impl.matchers.GroupMatcher;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@Service
public class QuartzManager {

@Autowired
private Scheduler sched;

/**
 * 增加一个job
 * @param jobClass 任务实现类
 * @param jobName 任务名称
 *  @param jobGroupName 任务组名
 * @param jobTime 时间表达式 （如：0/5 * * * * ? ）
 */
public  void addJob(Class<? extends Job> jobClass, String jobName,String jobGroupName,String jobTime) {
    try {
        //创建jobDetail实例，绑定Job实现类  
        //指明job的名称，所在组的名称，以及绑定job类
        JobDetail jobDetail = JobBuilder.newJob(jobClass)
                        .withIdentity(jobName, jobGroupName)//任务名称和组构成任务key
                        .build();
        //定义调度触发规则  
        //使用cornTrigger规则 
        Trigger trigger = TriggerBuilder.newTrigger()
                    .withIdentity(jobName, jobGroupName)//触发器key
                    .startAt(DateBuilder.futureDate(1, IntervalUnit.SECOND))
                    .withSchedule(CronScheduleBuilder.cronSchedule(jobTime))
                    .startNow().build();
        //把作业和触发器注册到任务调度中
        sched.scheduleJob(jobDetail, trigger);
        // 启动
        if (!sched.isShutdown()) {
            sched.start();
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

/**
 * 增加一个job
 * @param jobClass  任务实现类
 * @param jobName  任务名称
 * @param jobGroupName 任务组名
 * @param jobTime  时间表达式 (这是每隔多少秒为一次任务)
 */
public void addJob(Class<? extends Job> jobClass, String jobName,String jobGroupName,int jobTime){
    addJob(jobClass,jobName,jobGroupName,jobTime,-1);
}

/**
 * 增加一个job
 * @param jobClass 任务实现类
 * @param jobName  任务名称
 * @param jobGroupName 任务组名
 * @param jobTime  时间表达式 (这是每隔多少秒为一次任务)
 * @param jobTimes  运行的次数 （<0:表示不限次数）
 */
public void addJob(Class<? extends Job> jobClass, String jobName,String jobGroupName,int jobTime,int jobTimes){
     try {
         JobDetail jobDetail = JobBuilder.newJob(jobClass)
                         .withIdentity(jobName, jobGroupName)//任务名称和组构成任务key
                         .build();
       //使用simpleTrigger规则
         Trigger trigger=null;
         if(jobTimes<0){
             trigger=TriggerBuilder.newTrigger().withIdentity(jobName, jobGroupName)  
                    .withSchedule(SimpleScheduleBuilder.repeatSecondlyForever(1).withIntervalInSeconds(jobTime))  
                    .startNow().build();
         }else{
             trigger=TriggerBuilder.newTrigger().withIdentity(jobName, jobGroupName)  
                    .withSchedule(SimpleScheduleBuilder.repeatSecondlyForever(1).withIntervalInSeconds(jobTime).withRepeatCount(jobTimes))  
                    .startNow().build();
         }
        sched.scheduleJob(jobDetail, trigger);
        if (!sched.isShutdown()) {
            sched.start();
        }
    } catch (SchedulerException e) {
        e.printStackTrace();
    }
}

/**
 * 修改 一个job的 时间表达式
 * @param jobName
 * @param jobGroupName
 * @param jobTime
 */
public void updateJob(String jobName,String jobGroupName,String jobTime){
    try {
        TriggerKey triggerKey = TriggerKey.triggerKey(jobName, jobGroupName);  
        CronTrigger trigger = (CronTrigger) sched.getTrigger(triggerKey);  
        trigger = trigger.getTriggerBuilder().withIdentity(triggerKey)
                .withSchedule(CronScheduleBuilder.cronSchedule(jobTime))
                .build();
        //重启触发器
        sched.rescheduleJob(triggerKey, trigger);
    } catch (SchedulerException e) {
        e.printStackTrace();
    }  
}

/**
 * 删除任务一个job
 * @param jobName 任务名称
 * @param jobGroupName 任务组名
 */
public  void deleteJob(String jobName,String jobGroupName) {
    try {
        sched.deleteJob(new JobKey(jobName, jobGroupName));
    } catch (Exception e) {
        e.printStackTrace();
    }
}

/**
 * 暂停一个job
 * @param jobName
 * @param jobGroupName
 */
public void pauseJob(String jobName,String jobGroupName){
    try {
        JobKey jobKey = JobKey.jobKey(jobName, jobGroupName);  
        sched.pauseJob(jobKey);
    } catch (SchedulerException e) {
        e.printStackTrace();
    } 
}

/**
 * 恢复一个job
 * @param jobName
 * @param jobGroupName
 */
public void resumeJob(String jobName,String jobGroupName){
    try {
        JobKey jobKey = JobKey.jobKey(jobName, jobGroupName);
        sched.resumeJob(jobKey);
    } catch (SchedulerException e) {
        e.printStackTrace();
    }
}

/**
 * 立即执行一个job
 * @param jobName
 * @param jobGroupName
 */
public void runAJobNow(String jobName,String jobGroupName){
    try {
        JobKey jobKey = JobKey.jobKey(jobName, jobGroupName);
        sched.triggerJob(jobKey);
    } catch (SchedulerException e) {
        e.printStackTrace();
    }
}

/**
 * 获取所有计划中的任务列表
 * @return
 */
public List<Map<String,Object>> queryAllJob(){
    List<Map<String,Object>> jobList=null;
    try {
         GroupMatcher<JobKey> matcher = GroupMatcher.anyJobGroup();  
         Set<JobKey> jobKeys = sched.getJobKeys(matcher);
         jobList = new ArrayList<Map<String,Object>>();  
         for (JobKey jobKey : jobKeys) {  
              List<? extends Trigger> triggers = sched.getTriggersOfJob(jobKey);  
              for (Trigger trigger : triggers) {  
                  Map<String,Object> map=new HashMap<>();
                  map.put("jobName",jobKey.getName());
                  map.put("jobGroupName",jobKey.getGroup());
                  map.put("description","触发器:" + trigger.getKey());
                  Trigger.TriggerState triggerState = sched.getTriggerState(trigger.getKey());  
                  map.put("jobStatus",triggerState.name());
                  if (trigger instanceof CronTrigger) {  
                      CronTrigger cronTrigger = (CronTrigger) trigger;  
                      String cronExpression = cronTrigger.getCronExpression();  
                      map.put("jobTime",cronExpression);
                  }  
                  jobList.add(map);  
              }  
          }  
    } catch (SchedulerException e) {
        e.printStackTrace();
    }  
    return jobList;  
}

/**
 * 获取所有正在运行的job
 * @return
 */
public List<Map<String,Object>> queryRunJon(){
    List<Map<String,Object>> jobList=null;
    try {
        List<JobExecutionContext> executingJobs = sched.getCurrentlyExecutingJobs();
        jobList = new ArrayList<Map<String,Object>>(executingJobs.size());  
        for (JobExecutionContext executingJob : executingJobs) {  
            Map<String,Object> map=new HashMap<String, Object>();  
            JobDetail jobDetail = executingJob.getJobDetail();  
            JobKey jobKey = jobDetail.getKey();  
            Trigger trigger = executingJob.getTrigger(); 
            map.put("jobName",jobKey.getName());
            map.put("jobGroupName",jobKey.getGroup());
            map.put("description","触发器:" + trigger.getKey());
            Trigger.TriggerState triggerState = sched.getTriggerState(trigger.getKey());  
            map.put("jobStatus",triggerState.name());
            if (trigger instanceof CronTrigger) {  
                CronTrigger cronTrigger = (CronTrigger) trigger;  
                String cronExpression = cronTrigger.getCronExpression();  
                map.put("jobTime",cronExpression);
            }  
            jobList.add(map);  
        }  
    } catch (SchedulerException e) {
        e.printStackTrace();
    }  
    return jobList;  
}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247

5、job类：

package com.yj.quartzjob;

import java.text.SimpleDateFormat;
import java.util.Date;
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import com.yj.service.WeiXinService;
/**
* quart test
* @author jing
*
*/
@Component
public class QuartzJob implements Job{
@Autowired
public WeiXinService service;

@Override
public void execute(JobExecutionContext arg0) throws JobExecutionException {
    SimpleDateFormat dateFormat=new SimpleDateFormat("yyyy-MM-dd HH-mm-ss");
    System.out.println("TestQuartJob 的运行 ："+dateFormat.format(new Date()));
    service.getAccessToken();
}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

6、测试类：

@RequestMapping(“add”)
public void text(){

    try {
        String jobName="job1";
        String jobGroupName="job1";
        String jobTime="0/5 * * * * ? ";
        SimpleDateFormat dateFormat=new SimpleDateFormat("yyyy-MM-dd HH-mm-ss");
        System.out.println("TestQuartJob 开始启动："+dateFormat.format(new Date()));
        quartzManager.addJob(QuartzJob.class,jobName,jobGroupName,jobTime);
    } catch (Exception e) {
        e.printStackTrace();
    } 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

7、maven引入：

        <!-- https://mvnrepository.com/artifact/org.quartz-scheduler/quartz -->
        <dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz</artifactId>
            <version>2.2.1</version>
        </dependency>

1
2
3
4
5
6

8、监听器：
自定义一个监听类：

貌似Quartz的job在项目重启时，job都失效了，我是把每次启动的job都存放在数据库，然后项目启动时监听器读取数据库的job，然后添加job。

package com.yj.quartzjob;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import org.quartz.Job;
import org.springframework.web.context.support.WebApplicationContextUtils;
import com.yj.until.QuartzManager;

/**
* 容器监听器
* @author jing
*/
public class QuartzJobListener implements ServletContextListener {

public void contextInitialized(ServletContextEvent arg0) {
    /***处理获取数据库的job表，然后遍历循环每个加到job中 ***/
    QuartzManager quartzManager = WebApplicationContextUtils.getWebApplicationContext(arg0.getServletContext()).getBean(QuartzManager.class);

    //此处就不写获取数据库了，模拟一个集合遍历的数据  
    List<Map<String,Object>> listMap=new ArrayList<>();
    Map<String, Object> map1=new HashMap<String, Object>();
    map1.put("jobClass","com.yj.quartzjob.QuartzJob");
    map1.put("jobName","job1");
    map1.put("jobGroupName","job1");
    map1.put("jobTime","0/5 * * * * ? ");
    listMap.add(map1);

    for (Map<String, Object> map : listMap) {
        try {
            quartzManager.addJob((Class<? extends Job>)(Class.forName((String)map1.get("jobClass")).newInstance().getClass()),(String)map.get("jobName"), (String)map.get("jobGroupName"),(String)map.get("jobTime"));
        } catch (Exception e) {
            e.printStackTrace();
        } 
    }
    System.out.println("QuartzJobListener 启动了");
}
public void contextDestroyed(ServletContextEvent arg0) {
}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

web.xml的配置：

ps：自定义的监听类要在SpringMVC框架的监听器之后。


org.springframework.web.context.ContextLoaderListener


com.yj.quartzjob.QuartzJobListener

wearenazimdb
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Spring quartz Job依赖注入使用详解
10-19
主要介绍了Spring quartz Job依赖注入使用详解的相关资料,Spring quartz Job不能依赖注入，Spring整合quartz Job任务不能注入Spring4整合quartz2.2.3中Job任务使用@Autowired不能注入，需要的朋友可以参考下
Spring整合Quartz Job以及Spring Task的实现方法
08-28
Spring整合Quartz Job以及Spring Task的实现方法 Spring Framework是Java开发中最流行的框架之一，它提供了许多强大的功能来帮助开发者快速构建企业级应用程序。在企业级应用程序中，定时任务是一个非常重要的组件...
Quartz与Spring的整合-Quartz中的job如何自动注入spring容器托管的对象
zhangying010的专栏
07-05 592
转自  http://blog.arganzheng.me/posts/quartz-and-spring-integration-ioc-autowire.html     Quartz与Spring的整合-Quartz中的job如何自动注入spring容器托管的对象 December 29, 2012 问题 Quartz中的job是由Quartz框架动态创建的（配置该job的cl...
解决quartz的job无法注入spring对象
方块糖的博客
12-12 9808
一般情况下，quartz的job中使用autowired注解注入的对象为空，这时候我们就要使用spring-quartz提供的AdaptableJobFactory类。 自定义一个类: [java] view plain copy   public class JobFactory extends AdaptableJobFactory {    
quartz job中无法注入spring
qq_36350477的博客
12-18 227
public class SchedulerAlertJob implements Job {             @Autowired     private JdbcTemplate jdbcTemplateExt;     @Override     public void execute(JobExecutionContext content) throws JobExecutio...
框架学习 三 Spring 、02(maven,mybatis,spring,springmvc) 夹带设计模式
JinMujun的博客
10-24 186
1bean作用域 bean的作用域有7种，最常用的**有单例和原型 还有request 、 session、 globalSession、 application、 websocket singleton 单例 singleton是Spring容器默认的作用域，当Bean的作用域为singleton时，Spring容器就只会存在一个共享的Bean实例。singleton作用域对于无会话状态的Bean（如Dao 组件、Service组件）来说，是最理想的选择。 在配置文件声明bean 在容器只有一个唯一be
解决使用Quartz执行的任务对象（job）中无法注入bean的问题
weiambt的博客
06-30 2683
springBoot整合Quartz后，job中注入的业务service，使用@Autowired获取的对象为null
Quartz定时任务中Job对象无法直接用@Autowired注入的问题
qq_31856061的博客
09-23 2019
在定时任务中~直接使用@Autowired注入业务，启动任务时报空指针错误 @Component public class VisualDataUploadJob implements Job { @Autowired private IVisualizationService visualizationService; @Override public void execute(JobExecutionContext jobExecutionContext) throws
Spring Boot集成Quartz注入Spring管理的类的方法
08-27
本篇文章主要介绍了Spring Boot集成Quartz注入Spring管理的类的方法，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
SpringQuartz的使用文档
09-17
Spring对Quartz进行了集成，使其更易于在Spring应用程序中使用。Spring提供了`FactoryBean`类，如`SchedulerFactoryBean`，用于创建和管理Quartz的`Scheduler`实例。这使得我们可以利用Spring的依赖注入（DI）和管理...
spring整合quartz使用jdbc存储
08-03
下面将详细介绍如何进行Spring与Quartz的整合，以及使用JDBC存储的相关步骤。 1. **Spring与Quartz的整合** 首先，我们需要在项目中引入Spring和Quartz的相关依赖。在Maven或Gradle的pom.xml或build.gradle文件中...
Quartz在springmvc中自动注入失败
qq_36350266的博客
10-13 374
什么是Quartz Quartz是一个由java编写的开源作业调度框架，简单来说，Quartz就是启动定时任务的框架，像linux系统中的corntab，可以定时启动任务. Quartz的单独使用 Scheduler 定时器对象 JobDetail 任务对象 Trigger 触发器对象 SimpleTrigger 简单触发器 CornTrigger任务调度触发器 使用 导入Maven坐标 <dependency> <groupId>o...
解决quartz在spring中，无法获取注入bean的问题
qq_41283321的博客
10-27 683
问题描述： 代码中 execute()方法中， purchaseOrderService空指针异常！ mapper或者dao层的也是如此； 详见下面代码 public class YgPurchaseOrderJob extends BaseAction implements Job { private static Logger logger = Logger.getLogger(YgPurchaseOrderJob.class); @Autowired Purch..
在使用spring整合quartz时,工作类中无法使用Spring的注入,需要手动注入
qq_46239275的博客
06-22 206
第一次使用quartz定时任务,遇到的问题挺多的,这就是其中一个; 我在使用spring整合quartz时,在逻辑代码中以为所有逻辑都写好了,在运行时,信息数据为空,查了许多资料才发现,在quartz的逻辑代码中无法使用Spring的注入,所以只能手动注入 注入类: package org.springblade.modules.quartz.util; import org.springframework.beans.BeansException; import org.springframework.
Quartz 定时任务 (3) —— 解决spring 无法注入
haiyanghan的博客
11-28 951
解决service无法注入 原因是job的实现类是在quartz中实例化出来的，不受spring的管理。所以就导致注入不进去了 1. 创建job工厂类 @Component public class JobFactory extends AdaptableJobFactory { /** * AutowireCapableBeanFactory接口是BeanFactory的子类 * 可以连接和填充那些生命周期不被Spring管理的已存在的bean实例 */ pr
quartz无法注入springbean的原因
u012497072的博客
01-07 576
参考：https://zhuanlan.zhihu.com/p/146060950 如何解决 Quartz Job 中无法注入 Spring Bean xkcoding xkcoding ​ Later Equals Never 问题 不知道小伙伴们在 Spring 集成 Quartz 的时候有没有遇到过这样一个问题，就是在 Quartz 的 Job 中 @Autowired 一个 Spring Bean 的时候会报空指针异常。如果在 Spring 中无法使用 @Autowired 进行注入一个 Bea
spring项目中quartz的job类不能自动注入bean的问题
zcb18202832593的博客
02-27 2082
在execute（）方法中加入以下红色部分代码：           //定时清除失效商品public class ClearInvalidGoodsJob implements Job { @Autowired private GoodsInfoService goodsInfoservice; @Override public void execute(JobExecutionContext ...
蒙牛智能化改造解决方案.docx
最新发布
08-17
蒙牛智能化改造解决方案.docx
怎么使用spring quartz调用spring batch job
05-26
使用Spring Quartz调用Spring Batch Job可以通过以下步骤实现： 1. 首先，需要在Spring Batch中定义一个Job，例如： ```java @Bean public Job myJob() { return jobBuilderFactory.get("myJob") .incrementer...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值