springboot动态定时任务的实现方法示例

痛定思痛。 2022-10-28 10:08 179阅读 0赞

1、maven引入quartz包

1  
2  
3  
4  
5  
6  
  
<dependency>  
<groupId>org.quartz-scheduler</groupId>  
<artifactId>quartz</artifactId>  
<version>2.3.2</version>  
</dependency>  
2、创建定时任务工厂类

1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
/\*\*  
\* 定时任务工厂类  
\*/  
@Component  
public class JobFactory extends SpringBeanJobFactory implements ApplicationContextAware \{  
  
private transient AutowireCapableBeanFactory beanFactory;  
  
@Override  
protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception \{  
final Object jobInstance = super.createJobInstance(bundle);  
beanFactory.autowireBean(jobInstance);  
return jobInstance;  
\}  
  
@Override  
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException \{  
this.beanFactory = applicationContext.getAutowireCapableBeanFactory();  
\}  
  
\}  
3、创建定时任务抽象类

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  
public abstract class AbstractTask implements Job \{  
  
private Logger logger = LoggerFactory.getLogger(AbstractTask.class);  
  
protected abstract void executeInternal(JobExecutionContext context) throws Exception;  
  
/\*\*  
\* 定时任务标识  
\*/  
private String key;  
  
/\*\*  
\* 数据库里配置的主键id  
\*/  
private Long dataBaseId;  
  
@Override  
public void execute(JobExecutionContext context) \{  
try \{  
executeInternal(context);  
\} catch (Exception e) \{  
logger.error(e.getMessage(), e);  
logger.error("job execute failed!");  
\}  
\}  
  
public String getKey() \{  
return key;  
\}  
  
public void setKey(String key) \{  
this.key = key;  
\}  
  
public Long getDataBaseId() \{  
return dataBaseId;  
\}  
  
public void setDataBaseId(Long dataBaseId) \{  
this.dataBaseId = dataBaseId;  
\}  
\}  
4、创建定时任务业务实现类

这里可以写你的业务代码，实现具体的业务逻辑。

1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
@Component("JobTask")  
public class JobTask extends AbstractTask \{  
  
@Override  
protected void executeInternal(JobExecutionContext context) \{  
System.out.println("key = " + this.getKey());  
System.out.println("dataBaseId = " + this.getDataBaseId());  
\}  
  
\}  
5、创建定时任务管理器

包括项目启动时添加定时任务，手动添加定时任务，更新定时任务，删除定时任务方法。

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  
/\*\*  
\* 定时任务管理容器 component （单例模式）  
\*/  
@Component  
@Scope("singleton")  
public class JobQuartzManager implements ApplicationContextAware \{  
  
/\*\*  
\* 创建新的scheduler  
\*/  
private static SchedulerFactory schedulerFactory = new StdSchedulerFactory();  
  
private Scheduler scheduler;  
  
/\*\*  
\* 定义组名称，不同的组用于区分任务  
\*/  
private static final String JOB\_GROUP\_NAME = "JOB\_GROUP\_NAME";  
  
private static final String TRIGGER\_GROUP\_NAME = "TRIGGER\_GROUP\_NAME";  
  
/\*\*  
\* 日志  
\*/  
private Logger logger = LoggerFactory.getLogger(JobQuartzManager.class);  
  
private ApplicationContext applicationContext;  
  
@Autowired  
private JobFactory jobFactory;  
  
public void start() \{  
//启动定时任务（初始化）  
try \{  
this.scheduler = schedulerFactory.getScheduler();  
scheduler.setJobFactory(jobFactory); //设置定时任务工厂模式  
//项目启动时默认给spring容器添加动态的定时任务  
this.addJob("job" + 100L, 100L, JobTask.class, "0/2 \* \* \* \* ?");  
\} catch (SchedulerException e) \{  
logger.error(e.getMessage(), e);  
throw new RuntimeException("init Scheduler failed");  
\}  
\}  
  
public boolean addJob(String jobName, Long dataBaseId, Class jobClass, String cronExp) \{  
boolean result = false;  
if (!CronExpression.isValidExpression(cronExp)) \{  
logger.error("Illegal cron expression format(\{\})", cronExp);  
return result;  
\}  
try \{  
JobDetail jobDetail = JobBuilder.newJob().withIdentity(new JobKey(jobName, JOB\_GROUP\_NAME))  
.ofType((Class<AbstractTask>) Class.forName(jobClass.getName()))  
.build();  
//创建完jobDetail之后，使用语句传参数值，方便定时任务内部识别它是什么标识  
JobDataMap jobDataMap = jobDetail.getJobDataMap();  
jobDataMap.put("key", jobName);  
jobDataMap.put("dataBaseId", dataBaseId);  
Trigger trigger = TriggerBuilder.newTrigger()  
.forJob(jobDetail)  
.withSchedule(CronScheduleBuilder.cronSchedule(cronExp))  
.withIdentity(new TriggerKey(jobName, TRIGGER\_GROUP\_NAME))  
.build();  
scheduler.scheduleJob(jobDetail, trigger);  
scheduler.start();  
result = true;  
\} catch (Exception e) \{  
logger.error(e.getMessage(), e);  
logger.error("QuartzManager add job failed");  
\}  
return result;  
\}  
  
public boolean updateJob(String jobName, String cronExp) \{  
boolean result = false;  
if (!CronExpression.isValidExpression(cronExp)) \{  
logger.error("Illegal cron expression format(\{\})", cronExp);  
return result;  
\}  
JobKey jobKey = new JobKey(jobName, JOB\_GROUP\_NAME);  
TriggerKey triggerKey = new TriggerKey(jobName, TRIGGER\_GROUP\_NAME);  
try \{  
if (scheduler.checkExists(jobKey) && scheduler.checkExists(triggerKey)) \{  
JobDetail jobDetail = scheduler.getJobDetail(jobKey);  
Trigger newTrigger = TriggerBuilder.newTrigger()  
.forJob(jobDetail)  
.withSchedule(CronScheduleBuilder.cronSchedule(cronExp))  
.withIdentity(new TriggerKey(jobName, TRIGGER\_GROUP\_NAME))  
.build();  
scheduler.rescheduleJob(triggerKey, newTrigger);  
result = true;  
\} else \{  
logger.error("update job name:\{\},group name:\{\} or trigger name:\{\},group name:\{\} not exists..",  
jobKey.getName(), jobKey.getGroup(), triggerKey.getName(), triggerKey.getGroup());  
\}  
\} catch (SchedulerException e) \{  
logger.error(e.getMessage(), e);  
logger.error("update job name:\{\},group name:\{\} failed!", jobKey.getName(), jobKey.getGroup());  
\}  
return result;  
\}  
  
public boolean deleteJob(String jobName) \{  
boolean result = false;  
JobKey jobKey = new JobKey(jobName, JOB\_GROUP\_NAME);  
try \{  
if (scheduler.checkExists(jobKey)) \{  
result = scheduler.deleteJob(jobKey);  
\} else \{  
logger.error("delete job name:\{\},group name:\{\} not exists.", jobKey.getName(), jobKey.getGroup());  
\}  
\} catch (SchedulerException e) \{  
logger.error(e.getMessage(), e);  
logger.error("delete job name:\{\},group name:\{\} failed!", jobKey.getName(), jobKey.getGroup());  
\}  
return result;  
\}  
  
@Override  
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException \{  
this.applicationContext = applicationContext;  
\}  
  
\}  
6、创建定时任务启动类

项目运行时给spring注入定时任务

1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
/\*\*  
\* 定时任务启动类  
\*/  
@Component  
public class JobRunner implements ApplicationRunner \{  
  
//注入定时任务管理器  
@Autowired  
private JobQuartzManager quartzManager;  
  
/\*\*  
\* 项目启动时激活定时任务  
\*/  
@Override  
public void run(ApplicationArguments applicationArguments) \{  
System.out.println("--------------------注入定时任务---------------------");  
quartzManager.start();  
System.out.println("--------------------定时任务注入完成---------------------");  
\}  
  
\}  
7、测试案例

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  
@RestController  
@RequestMapping("/job")  
public class JobController \{  
  
@Autowired  
JobQuartzManager quartzManager;  
  
@PostMapping("addJob")  
@ResponseBody  
public String addJob(@RequestParam("dataBaseId") Long dataBaseId, @RequestParam("cronExp") String cronExp)\{  
boolean success = quartzManager.addJob("job" + dataBaseId, dataBaseId, JobTask.class, cronExp);  
if(success)\{  
return "添加成功";  
\}else\{  
return "添加失败！";  
\}  
\}  
  
@PostMapping("deleteJob")  
@ResponseBody  
public String deleteJob(@RequestParam("jobName") String jobName)\{  
boolean success = quartzManager.deleteJob(jobName);  
if(success)\{  
return "删除成功";  
\}else\{  
return "删除失败！";  
\}  
\}  
  
@PostMapping("updateJob")  
@ResponseBody  
public String updateJob(@RequestParam("jobName") String jobName, @RequestParam("cronExp") String cronExp)\{  
boolean success = quartzManager.updateJob(jobName, cronExp);  
if(success)\{  
return "更新成功";  
\}else\{  
return "更新失败！";  
\}  
\}  
  
\}  
总结

到此这篇关于springboot实现动态定时任务的文章就介绍到这了