Springboot+Quarts实现定时任务调度

立即下载用AI写一个

发布时间：2019-10-21

8人 | 浏览：2153次 | 收藏 |

技术：Springboot2.1.9.RELEASE+quartz2.2.3

运行环境：mysql5.7+springboot2.1.9

概述

本篇文章通过搭建一个简单的Springboot项目，结合Quartz来说明定时任务在Javaweb中的工作原理及实现过程

详细

#### 0. 项目结构

本篇文章通过搭建一个简单的Springboot项目，结合Quartz来说明定时任务在Javaweb中的工作原理及实现过程。
![](/contentImages/image/20191021/xtusEKlajfagsmdLFKe.png)

#### 1. Quartz简介

Quartz框架的核心是调度器。调度器负责管理Quartz应用运行时环境。调度器不是靠自己做所有的工作，而是依赖框架内一些非常重要的部件。Quartz不仅仅是线程和线程管理。为确保可伸缩性，Quartz采用了基于多线程的架构。启动时，框架初始化一套worker线程，这套线程被调度器用来执行预定的作业。这就是Quartz怎样能并发运行多个作业的原理。Quartz依赖一套松耦合的线程池管理部件来管理线程环境。

####  2. 项目相关

该定时器Demo用于定时执行制定路径下的jar包的编译,也可以用于普通的任务调度.通过对任务的查询修改删除来管理整个列表文件.可以通关开启和关闭来更改jar的开始执行状态(开启后如果需要停止只能关闭或重启服务器才能生效,具体的解决办法还在改进中).相关的一整套的UI界面比较简略,可以进行二次开发,主要整合了JPA的分页查询,可以查看相关代码部分.

![](/contentImages/image/20191021/xaO2MV2fvWtshqtVeQR.png)

#### 3. 引入Quartz相关依赖

在pom.xml文件中加入quartz的依赖坐标。

```java

        <dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz</artifactId>
            <version>2.3.0</version>
        </dependency>
```

##### 4. 访问路径
启动QuartzDemoApplication.java，即可运行Springboot程序，使用如下地址访问网站。
```java
http://localhost:9090/
```

##### 5. 代码相关

##### Quartz相关控制器:
其中包含初始化启动所有的Job，重启访问某一个Job以及返回Job列表等信息。

```java
@Controller
@RequestMapping("/")
public class QuartzController {

private static final Logger logger = LoggerFactory.getLogger(QuartzController.class);
    @Autowired
    private SchedulerFactoryBean schedulerFactoryBean;
    @Autowired
    private QuartzService jobService;

//初始化启动所有的Job
    @PostConstruct
    public void initialize() {
        try {
            reStartAllJobs();
            logger.info("INIT SUCCESS");
        } catch (SchedulerException e) {
            logger.info("INIT EXCEPTION : " + e.getMessage());
            e.printStackTrace();
        }
    }

//根据ID重启某个Job
    @RequestMapping("/refresh/{id}")
    public String refresh(@PathVariable Integer id) throws SchedulerException {
        String result;
        JobEntity entity = jobService.getJobEntityById(id);
        if (entity == null){
            return "error: id is not exist ";
        }
        synchronized (logger) {
            JobKey jobKey = jobService.getJobKey(entity);
            Scheduler scheduler = schedulerFactoryBean.getScheduler();
            scheduler.pauseJob(jobKey);
            scheduler.unscheduleJob(TriggerKey.triggerKey(jobKey.getName(), jobKey.getGroup()));
            scheduler.deleteJob(jobKey);
            JobDataMap map = jobService.getJobDataMap(entity);
            JobDetail jobDetail = jobService.geJobDetail(jobKey, entity.getDescription(), map);
            if (entity.getStatus().equals("OPEN")) {
                scheduler.scheduleJob(jobDetail, jobService.getTrigger(entity));
                result = "Refresh Job : " + entity.getName() + "\t jarPath: " + entity.getJarPath() + " success !";
            } else {
                result = "Refresh Job : " + entity.getName() + "\t jarPath: " + entity.getJarPath() + " failed ! , " +
                        "Because the Job status is " + entity.getStatus();
            }
        }
        return result;
    }

/**
     * 重新启动所有的job
     */
    private void reStartAllJobs() throws SchedulerException {

synchronized (logger) {
            Scheduler scheduler = schedulerFactoryBean.getScheduler();

Set<JobKey> jobKeys = scheduler.getJobKeys(GroupMatcher.anyGroup());

scheduler.pauseJobs(GroupMatcher.anyGroup());//暂停所有JOB

for (JobKey jobKey : jobKeys) {  //删除从数据库中注册的所有JOB
                logger.info("jobKey==>"+jobKey+"\n");
                scheduler.unscheduleJob(TriggerKey.triggerKey(jobKey.getName(), jobKey.getGroup()));
                scheduler.deleteJob(jobKey);
            }

//从数据库中注册的所有JOB
            for (JobEntity job : jobService.loadJobs()) {
                logger.info("Job register name : {} , group : {} , cron : {}", job.getName(), job.getGroup(), job.getCron());

JobDataMap map = jobService.getJobDataMap(job);
                JobKey jobKey = jobService.getJobKey(job);

JobDetail jobDetail = jobService.geJobDetail(jobKey, job.getDescription(), map);
                if (job.getStatus().equals("OPEN")) {
                    scheduler.scheduleJob(jobDetail, jobService.getTrigger(job));
                } else {
                    logger.info("Job jump name : {} , Because {} status is {}", job.getName(), job.getName(), job.getStatus());
                }
            }
        }
    }

@RequestMapping("/test/{id}")
    @ResponseBody
    public JobEntity testList(@PathVariable("id") int id) {
        JobEntity jobEntity = jobService.getById(id);

return jobEntity;

}

@RequestMapping("/tablePage")
    public String quartzList() {
        return "table_page";
    }

}

```

##### 6. DynamicJob:

在这个方法中说明了Quartz调用Job的方法及所使用到的相关接口。

```java
/**
 * :@DisallowConcurrentExecution : 此标记用在实现Job的类上面,意思是不允许并发执行.
 * :注意org.quartz.threadPool.threadCount线程池中线程的数量至少要多个,否则@DisallowConcurrentExecution不生效
 * :假如Job的设置时间间隔为3秒,但Job执行时间是5秒,设置@DisallowConcurrentExecution以后程序会等任务执行完毕以后再去执行,否则会在3秒时再启用新的线程执行
 */
@DisallowConcurrentExecution
@PersistJobDataAfterExecution
@Component
@Slf4j
public class DynamicJob implements Job {
	private Logger logger = LoggerFactory.getLogger(DynamicJob.class);

/**
	 * 核心方法,Quartz Job真正的执行逻辑. executorContext
	 * JobExecutionContext中封装有Quartz运行所需要的所有信息
	 * @throws JobExecutionException execute()方法只允许抛出JobExecutionException异常
	 */
	@Override
	public void execute(JobExecutionContext executionContext) throws JobExecutionException {

JobDataMap map = executionContext.getMergedJobDataMap();

String jarPath = map.getString("jarPath");
		String parameter = map.getString("parameter");
		String vmParam = map.getString("vmParam");
		long startTime = System.currentTimeMillis();
		if (!StringUtils.getStringUtil.isEmpty(jarPath)) {

File jar = new File(jarPath);
			if (jar.exists()) {
				ProcessBuilder processBuilder = new ProcessBuilder();
				processBuilder.directory(jar.getParentFile());
				/**
				 * 这个是java的执行命令 java -jar
				 */
				List<String> commands = new ArrayList<>();
				commands.add("java");
				if (!StringUtils.getStringUtil.isEmpty(vmParam)) {
					commands.add(vmParam);
				}
				commands.add("-jar");
				commands.add(jarPath);
				commands.add(" &");
				System.out.println("commands->\n" + commands);

if (!StringUtils.getStringUtil.isEmpty(parameter)) {

commands.add(parameter);
					processBuilder.command(commands);
					logger.info("Running Job details as follows >>>>>>>>>>>>>>>>>>>>: ");
					logger.info("Running Job commands : {}  ", StringUtils.getStringUtil.getListString(commands));
					try {
						Process process = processBuilder.start();
						logProcess(process.getInputStream(), process.getErrorStream());
					} catch (Exception e) {
						e.printStackTrace();
					}
				} else {
					throw new JobExecutionException("Job Jar not found >>  " + jarPath);
				}
				long endTime = System.currentTimeMillis();
				logger.info(">>>>>>>>>>>>> Running Job has been completed , cost time :  " + (endTime - startTime)+ "ms\n");
			}
		}
	}

// 打印Job执行内容的日志
	private void logProcess(InputStream inputStream, InputStream errorStream) throws IOException {
		String inputLine;
		String errorLine;
		BufferedReader inputReader = new BufferedReader(new InputStreamReader(inputStream));
		BufferedReader errorReader = new BufferedReader(new InputStreamReader(errorStream));
		while ((inputLine = inputReader.readLine()) != null) {
			logger.info(inputLine);
		}
		while ((errorLine = errorReader.readLine()) != null) {
			logger.error(errorLine);
		}
	}
}
```

#### 7. 结果展示
![](/contentImages/image/20191021/KHIeYAtKmQ1tq9ksaQf.png)
![](/contentImages/image/20191021/saRBKwNtzEvukRj43l9.png)
![](/contentImages/image/20191021/RhkQ0meeX6zBVOHxy3R.png)

本实例支付的费用只是购买源码的费用，如有疑问欢迎在文末留言交流，如需作者在线代码指导、定制等，在作者开启付费服务后，可以点击“购买服务”进行实时联系，请知悉，谢谢

感谢

手机上随时阅读、收藏该文章？请扫下方二维码

Springboot+Quarts实现定时任务调度

概述

详细

相似例子推荐

评论

作者

评分详细

作者例子