轻量级Spring+Quartz实现动态添加定时任务

立即下载用AI写一个

发布时间：2019-12-22

10人 | 浏览：3059次 | 收藏 |

技术：Spring+Quartz+Maven

运行环境：jdk1.8+maven

概述

使用maven构建项目，spring + quartz搭建，包含源码，API使用文档，以及打包好的jar包。源码导入即可运行，jar包添加到项目中即可使用。

详细

### 前言
**为什么说是轻量级？因为只包含quartz定时任务功能，直接打成jar包，可以运行于任何java环境构建的项目中。添加即可用，同时也提供了拓展性，可将源码进行适当的定制。**

### 概述
- 无spring , quartz 基础：

本着添加即用的原则，本demo可直接用于实战项目中，而且无需了解quartz。因为API文档已经给你写好了，直接按照示例调用即可。执行任务类型：windows,linux系统命令或者脚本。个性化任务，需要看下一点

- 熟悉Spring, Quartz：

可直接对源码进行改装和任务个性化定制

- 已经解决不同系统时区可能不同问题

统一转换成北京时间

- 使用步骤，下面介绍

### 项目结构

![](/contentImages/image/20191220/8a61hgOEZBqS6Vxme2A.png)

### 详细

#### 源码分析
##### 一、创建Job, 编写任务

```
/**
 * @Description 任务作业
 * @Date 2019/12/19 19:26
 * @Created by Jason
 */
// 保证任务一个接着一个执行
@DisallowConcurrentExecution
public class WorkJob implements Job{

public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        System.out.println(" ===== 开始执行作业! ======");

JobDataMap dataMap = jobExecutionContext.getMergedJobDataMap();
        String command = (String) dataMap.get("command");   // 接收JobDetail 传递过来的参数
        executeWork(command); // 若需要个性化定制任务, 再这里写你的逻辑就行啦
    }

// 执行具体作业
    private void executeWork(String command) {
        try {
            // 可以执行,windows / linux 命令, 脚本等
            System.out.println(command);
            Process exec = Runtime.getRuntime().exec(command);
            exec.waitFor();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

```
##### 二、创建并添加任务

```
   /**
     * 创建一个定时任务并启动
     *
     * @param jobName
     * @param cls
     * @param cron
     * @param command
     */
    public static void addJob(String jobName, Class cls, String cron, String command) {
        try {
            Scheduler sched = gSchedulerFactory.getScheduler();

JobDetail job = JobBuilder.newJob(cls).withIdentity(jobName, JOB_GROUP_NAME).build();

JobDataMap jobDataMap = job.getJobDataMap();
            // 传递参数
            jobDataMap.put("command", command);
//            jobDataMap.put("timingExpId", timingExpId);

// 表达式调度构建器
            CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(cron);

// 获取当前系统时间 转成 北京时间
            Date currTime = new Date(System.currentTimeMillis());
            Date date = changeTimeZone(currTime, TimeZone.getDefault(), TimeZone.getTimeZone("Asia/Shanghai"));

// 按新的cronExpression表达式构建一个新的trigger
            Trigger trigger = TriggerBuilder.newTrigger()
                    .withIdentity(jobName, TRIGGER_GROUP_NAME)
                    .withSchedule(scheduleBuilder)
                    .startAt(date)// 设置开始计时时间
                    .build();

// 交给scheduler去调度
            sched.scheduleJob(job, trigger);

// 启动
            if (!sched.isShutdown()) {
                sched.start();
                logger.info("新任务创建完毕，并启动 ！jobName：[" + jobName + "]");
            }
        } catch (Exception e) {
            logger.error("新任务创建、并启动 失败", e);
        }
    }

```
##### 三、移除一个定时任务

```
/**
     * 移除一个定时任务
     *
     * @param jobName
     */
    public static void removeJob(String jobName) {

TriggerKey triggerKey = TriggerKey.triggerKey(jobName, TRIGGER_GROUP_NAME);
        JobKey jobKey = JobKey.jobKey(jobName, JOB_GROUP_NAME);

try {
            Scheduler sched = gSchedulerFactory.getScheduler();

Trigger trigger = (Trigger) sched.getTrigger(triggerKey);
            if (trigger == null) {
                return;
            }

// 停止触发器
            sched.pauseTrigger(triggerKey);
            // 移除触发器
            sched.unscheduleJob(triggerKey);
            // 删除任务
            sched.deleteJob(jobKey);

logger.info("移除任务,完毕!jobName:[" + jobName + "]");
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
```
##### 四、查看当前任务状态

```
/**
     * 查到当前任务的状态
     *
     * @param jobName
     * @return NONE 无，
     * NORMAL, 正常
     * PAUSED, 暂停
     * COMPLETE, 完成
     * ERROR, 错误，
     * BLOCKED 受阻；
     */
    public static String getTriggerState(String jobName) {

TriggerKey triggerKey = TriggerKey.triggerKey(jobName, TRIGGER_GROUP_NAME);

String name = null;
        try {
            Scheduler sched = gSchedulerFactory.getScheduler();
            Trigger.TriggerState triggerState = sched.getTriggerState(triggerKey);
            name = triggerState.name();
        } catch (Exception e) {
            logger.error("获取任务状态失败！jobName:[" + jobName + "]", e);
        }
        return name;
    }
```
##### 五、读取配置文件, 配置文件方式更加灵活
支持配置文件方式,定义cron表达式和指令

- 例如：test.properties
```
command=sh /usr/local/test.sh
cron=*/5 * * * * ?
```
- 读取, 可读取任意目录的配置文件
- 使用时：直接传文件全路径名, 属性名

```
**
 * @Description 配置文件操作类
 * @Date 2019/12/19 20:09
 * @Created by Jason
 */
public class PropUtils {

private static String propPath;

private static Properties properties;

/**
     * 读取配置文件
     * @param path
     * @throws IOException
     */
    private static void read(String path) throws IOException {
        if (path!=null&&!"".equals(path)) {
            if (properties == null) {
                //可以读取任意路径的文件
                properties = new Properties();
                // 使用InPutStream流读取properties文件
                BufferedReader bufferedReader =
                        new BufferedReader(new FileReader(path));

properties.load(bufferedReader);
            }

}

propPath = path;
    }

/**
     * 获取配置属性
     * @param propPath
     * @param key
     * @return
     */
    public static String getPropValue(String propPath,String key) {
        try {
            read(propPath);
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println(">>>>>>>> 读取配置文件时发生异常!");
        }

return properties.getProperty(key);
    }

}
```

##### 六、使用示例

- 方式一： 直接将cron表达式, command执行命令, 当作参数传入即可

```
/**
 * @Description TODO
 * @Date 2019/12/19 20:53
 * @Created by Jason
 */
public class MainTest {

public static void main(String[] args) {
        String cron = "*/5 * * * * ?";
        String command = "sh /usr/local/test.sh"; // 执行一个脚本
        // 传入参数,启动
        QuartzManager.addJob("workJob",WorkJob.class,cron,command);
    }
}

```

- 方式二：

1.创建一个配置properties文件，并将corn表达式,command命令配置好

test.properties

```
command=sh /usr/local/test.sh
cron=*/5 * * * * ?
```

2.传入配置文件全路径名,并且读取配置, 然后调用执行

```
/**
 * @Description TODO
 * @Date 2019/12/19 20:53
 * @Created by Jason
 */
public class MainTest {

public static void main(String[] args) {
        // 获取文件配置属性, 参数： 配置文件地址 , 属性键
        String command = PropUtils.getPropValue("/usr/local/test.properties", "command");
        String cron = PropUtils.getPropValue("/usr/local/test.properties", "cron");

System.out.println(cron+"/"+command);

QuartzManager.addJob("workJob",WorkJob.class,cron,command);
    }
}

```

##### 七、自由定制任务

```
在WorkJob类的execute方法中编写你的任务逻辑即可
public void execute(JobExecutionContext jobExecutionContext);
```

##### 八、API文档
![](/contentImages/image/20191220/382UIj5J3ewzUfJ9yrj.png)

**本DEMO可直接应用到工作中，若有其他任务调度需求，请先修改源码重新打包。有其他疑问可联系作者！**

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

感谢

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

轻量级Spring+Quartz实现动态添加定时任务

概述

详细

相似例子推荐

评论

作者

评分详细

作者例子