可视化定时任务quartz集成解析全过程

quartz详解 quartz源码解析 quartz集群任务调度 2022-11-13 18:11:29 110人浏览独家记忆

Python 官方文档：入门教程 => 点击学习

摘要

目录前言1.目录结构2.原理3.表结构4.整合SpringBoot1.pom文件2.ScheduleConfig3.业务类4.运行配置5.ScheduleJob 6.Sch

前言

在日常的工作中，定时任务也是一个非常常见的需求，可以使用注解实现，但是使用这种方式有几个问题，首先就是如果修改比较麻烦，而且没有提供特定的页面对定时任务进行可视化管理。所以quartz就应运而生。本文将介绍如何实现springboot与quartz的整合。

1.目录结构

配置类配置SchedulerFactory固化定时任务和日志的业务类定时任务类运行配置

2.原理

scheduler是一个计划调度器容器（总部），容器里面可以盛放众多的JobDetail和trigger，当容器启动后，里面的每个JobDetail都会根据trigger按部就班自动去执行。
JobDetail是一个可执行的工作，它本身可能是有状态的。
Trigger代表一个调度参数的配置，什么时候去调。
当JobDetail和Trigger在scheduler容器上注册后，形成了装配好的作业（JobDetail和Trigger所组成的一对儿），就可以伴随容器启动而调度执行了。
scheduler是个容器，容器中有一个线程池，用来并行调度执行每个作业，这样可以提高容器效率

3.表结构

自带有11张系统表和2张业务表(自建)，其中绿色为自己建立的表

4.整合springboot

1.pom文件

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

2.ScheduleConfig

配置工厂类的参数。

@Configuration
public class ScheduleConfig {
 
	@Bean
	public SchedulerFactoryBean schedulerFactoryBean(DataSource dataSource) {
		SchedulerFactoryBean factory = new SchedulerFactoryBean();
		factory.setDataSource(dataSource);
		// quartz参数
		Properties prop = new Properties();
		prop.put("org.quartz.scheduler.instanceName", "QUARTZ");
		prop.put("org.quartz.scheduler.instanceId", "AUTO");
		// 线程池配置
		prop.put("org.quartz.threadPool.class", "org.quartz.simpl.SimpleThreadPool");
		prop.put("org.quartz.threadPool.threadCount", "20");
		prop.put("org.quartz.threadPool.threadPriority", "5");
		// JobStore配置
		prop.put("org.quartz.jobStore.class", "org.quartz.impl.jdbcjobstore.JobStoreTX");
		// 集群配置
		prop.put("org.quartz.jobStore.isClustered", "true");
		prop.put("org.quartz.jobStore.clusterCheckinInterval", "15000");
		prop.put("org.quartz.jobStore.maxMisfiresToHandleAtATime", "1");
		prop.put("org.quartz.jobStore.txIsolationLevelSerializable", "true");
		// sqlserver 启用
		prop.put("org.quartz.jobStore.misfireThreshold", "12000");
		prop.put("org.quartz.jobStore.tablePrefix", "QRTZ_");
		factory.setQuartzProperties(prop);
		factory.setSchedulerName("QUARTZ");
		// 延时启动
		factory.setStartupDelay(1);
		factory.setApplicationContextSchedulerContexTKEy("applicationContextKey");
		// 可选，QuartzScheduler
		// 启动时更新己存在的Job，这样就不用每次修改targetObject后删除qrtz_job_details表对应记录了
		factory.setOverwriteExistingJobs(true);
		// 设置自动启动，默认为true
		factory.setAutoStartup(true);
		return factory;
	}
}

3.业务类

主要是为页面提供接口。

@RestController
@RequestMapping("/qrtzJob")
public class QrtzJobController {
 
    @Autowired
    private QrtzJobService qrtzJobService;
 
    
    @GetMapping("/check")
    public boolean checkCron(String cron) {
        try {
            return CronExpression.isValidExpression(cron);
        } catch (Exception e) {
            return false;
        }
    }
 
    
    @GetMapping("/selectQrtzJob")
    @apiOperation(value = "通过实体查询", notes = "通过实体查询")
    public Result<List<QrtzJobVO>>
        selectQrtzJob(@ApiParam(name = "入参对象", value = "实体", required = false) QrtzJobVO qrtzJobVO) {
        Result<List<QrtzJobVO>> resultVO = new Result<>();
        // 业务查询
        List<QrtzJobVO> resultListQrtzJob = qrtzJobService.queryQrtzJobAll(qrtzJobVO);
        resultVO.setData(resultListQrtzJob);
        return resultVO;
    }
 
    
    @PostMapping("/createQrtzJob")
    @ApiOperation(value = "通过实体添加", notes = "通过实体添加")
    public Result
        createQrtzJob(@ApiParam(name = "入参对象", value = "实体", required = false) @RequestBody QrtzJobVO qrtzJobVO) {
        Result resultVO = new Result();
        // 业务处理
        qrtzJobService.createScheduleJob(qrtzJobVO);
        return resultVO;
    }
 
    
    @PutMapping("/updateQrtzJob")
    @ApiOperation(value = "通过实体修改", notes = "通过实体修改")
    public Result
        updateQrtzJob(@ApiParam(name = "入参对象", value = "实体", required = false) @RequestBody QrtzJobVO qrtzJobVO) {
        Result resultVO = new Result();
        // 业务处理
        qrtzJobService.updateScheduleJob(qrtzJobVO);
        return resultVO;
    }
 
    
    @DeleteMapping("/deleteQrtzJob")
    @ApiOperation(value = "通过实体删除", notes = "通过实体删除")
    public Result
        deleteQrtzJob(@ApiParam(name = "入参对象", value = "实体", required = false) @RequestBody QrtzJobVO qrtzJobVO) {
        Result resultVO = new Result();
        // 业务处理
        qrtzJobService.deleteScheduleJob(qrtzJobVO);
        return resultVO;
    }
 
    
    @GetMapping("/runJob")
    public Result
        runJob(@ApiParam(name = "入参对象", value = "实体", required = false) @RequestBody List<QrtzJobVO> qrtzJobVO) {
        Result resultVO = new Result();
        // 业务处理
        qrtzJobService.run(qrtzJobVO);
        return resultVO;
    }
 
    
    @GetMapping("/pauseJob")
    public Result
        pauseJob(@ApiParam(name = "入参对象", value = "实体", required = false) @RequestBody List<QrtzJobVO> qrtzJobVO) {
        Result resultVO = new Result();
        // 业务处理
        qrtzJobService.pause(qrtzJobVO);
        return resultVO;
    }
 
    @GetMapping("resumeJob")
    public Result
        resumeJob(@ApiParam(name = "入参对象", value = "实体", required = false) @RequestBody List<QrtzJobVO> qrtzJobVO) {
        Result resultVO = new Result();
        // 业务处理
        qrtzJobService.resume(qrtzJobVO);
        return resultVO;
    }
 
}

4.运行配置

ScheduleUtils:将新添加的trigger，jobDetail放入scheduler中。

public class ScheduleUtils {
 
    private static final Logger log = LoggerFactory.getLogger(ScheduleUtils.class);
 
    private static final String JOB_NAME_PREFIX = "TASK_";
 
    private static TriggerKey getTriggerKey(Long jobId) {
        return TriggerKey.triggerKey("TASK_" + jobId);
    }
 
    private static JobKey getJobKey(Long jobId) {
        return JobKey.jobKey("TASK_" + jobId);
    }
 
    public static CronTrigger getCronTrigger(Scheduler scheduler, Long jobId) {
        try {
            return (CronTrigger)scheduler.getTrigger(getTriggerKey(jobId));
        } catch (SchedulerException e) {
            log.error("获取Cron表达式失败", e);
            return null;
        }
    }
 
    public static void createScheduleJob(Scheduler scheduler, QrtzJobVO scheduleJob) {
        try {
            JobDetail jobDetail = JobBuilder.newJob(com.job.util.ScheduleJob.class)
                .withIdentity(getJobKey(scheduleJob.getJobId())).build();
            CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(scheduleJob.getCronExpression())
                .withMisfireHandlingInstructionDoNothing();
            CronTrigger trigger = (CronTrigger)TriggerBuilder.newTrigger()
                .withIdentity(getTriggerKey(scheduleJob.getJobId())).withSchedule(scheduleBuilder).build();
            jobDetail.getJobDataMap().put("JOB_PARAM_KEY", scheduleJob);
            scheduler.scheduleJob(jobDetail, trigger);
            if (scheduleJob.getStatus().equals(CommonConstant.QUARTZ_PAUSE)) {
                pauseJob(scheduler, scheduleJob.getJobId());
            }
        } catch (SchedulerException e) {
            log.error("创建定时任务失败", e);
        }
    }
 
    public static void updateScheduleJob(Scheduler scheduler, QrtzJobVO scheduleJob) {
        try {
            TriggerKey triggerKey = getTriggerKey(scheduleJob.getJobId());
            CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(scheduleJob.getCronExpression())
                .withMisfireHandlingInstructionDoNothing();
            CronTrigger trigger = getCronTrigger(scheduler, scheduleJob.getJobId());
            if (trigger == null) {
                throw new SchedulerException("获取Cron表达式失败");
            }
            trigger =
                (CronTrigger)trigger.getTriggerBuilder().withIdentity(triggerKey).withSchedule(scheduleBuilder).build();
            trigger.getJobDataMap().put("JOB_PARAM_KEY", scheduleJob);
            scheduler.rescheduleJob(triggerKey, trigger);
            if (scheduleJob.getStatus().equals(CommonConstant.QUARTZ_PAUSE)) {
                pauseJob(scheduler, scheduleJob.getJobId());
            }
        } catch (SchedulerException e) {
            log.error("更新定时任务失败", e);
        }
    }
 
    public static void run(Scheduler scheduler, QrtzJobVO scheduleJob) {
        try {
            JobDataMap dataMap = new JobDataMap();
            dataMap.put("JOB_PARAM_KEY", scheduleJob);
            scheduler.triggerJob(getJobKey(scheduleJob.getJobId()), dataMap);
        } catch (SchedulerException e) {
            log.error("执行定时任务失败", e);
        }
    }
 
    public static void pauseJob(Scheduler scheduler, Long jobId) {
        try {
            scheduler.pauseJob(getJobKey(jobId));
        } catch (SchedulerException e) {
            log.error("暂停定时任务失败", e);
        }
    }
 
    public static void resumeJob(Scheduler scheduler, Long jobId) {
        try {
            scheduler.resumeJob(getJobKey(jobId));
        } catch (SchedulerException e) {
            log.error("恢复定时任务失败", e);
        }
    }
 
    public static void deleteScheduleJob(Scheduler scheduler, Long jobId) {
        try {
            scheduler.deleteJob(getJobKey(jobId));
        } catch (SchedulerException e) {
            log.error("删除定时任务失败", e);
        }
    }
}

5.ScheduleJob

用于执行定时任务。

public class ScheduleJob extends QuartzJobBean {
 
    private static final Logger log = LoggerFactory.getLogger(ScheduleJob.class);
 
    private ExecutorService service = Executors.newSingleThreadExecutor();
 
    @Override
    protected void executeInternal(JobExecutionContext context) {
        QrtzJobVO scheduleJob = (QrtzJobVO)context.getMergedJobDataMap().get("JOB_PARAM_KEY");
        QrtzJobLogService scheduleJobLogService = (QrtzJobLogService) SprinGContextUtil.getBean(QrtzJobLogService.class);
        QrtzJobLogVO jobLog = new QrtzJobLogVO();
        jobLog.setJobId(scheduleJob.getJobId());
        jobLog.setBeanName(scheduleJob.getBeanName());
        jobLog.setMethodName(scheduleJob.getMethodName());
        if (CommonUtil.isEmpty(scheduleJob.getParams())) {
            jobLog.setParams("");
        } else {
            jobLog.setParams(scheduleJob.getParams());
        }
        long startTime = System.currentTimeMillis();
        try {
            log.info("任务准备执行，任务ID：{}", scheduleJob.getJobId());
            ScheduleRunnable task =
                new ScheduleRunnable(scheduleJob.getBeanName(), scheduleJob.getMethodName(), scheduleJob.getParams());
            Future<?> future = this.service.submit(task);
            future.get();
            long times = System.currentTimeMillis() - startTime;
            jobLog.setTimes(Long.valueOf(times));
            jobLog.setStatus("0");
            log.info("任务执行完毕，任务ID：{} 总共耗时：{} 毫秒", scheduleJob.getJobId(), Long.valueOf(times));
        } catch (Exception e) {
            log.error("任务执行失败，任务ID：" + scheduleJob.getJobId(), e);
            long times = System.currentTimeMillis() - startTime;
            jobLog.setTimes(Long.valueOf(times));
            jobLog.setStatus("1");
            jobLog.setError(StringUtils.substring(e.toString(), 0, 2000));
        } finally {
            scheduleJobLogService.insertQrtzJobLog(jobLog);
        }
    }
}

6.ScheduleRunnable

通过反射回去需要调用的类与方法。

public class ScheduleRunnable implements Runnable {
 
    private static final Logger log = LoggerFactory.getLogger(ScheduleRunnable.class);
 
    private Object target;
 
    private Method method;
 
    private String params;
 
    ScheduleRunnable(String beanName, String methodName, String params)
        throws NoSuchMethodException, SecurityException {
        this.target = SpringContextUtil.getBean(beanName);
        this.params = params;
        if (StringUtils.isNotBlank(params)) {
            this.method = this.target.getClass().getDeclaredMethod(methodName, new Class[] {String.class});
        } else {
            this.method = this.target.getClass().getDeclaredMethod(methodName, new Class[0]);
        }
    }
 
    @Override
    public void run() {
        try {
            ReflectionUtils.makeAccessible(this.method);
            if (StringUtils.isNotBlank(this.params)) {
                this.method.invoke(this.target, new Object[] {this.params});
            } else {
                this.method.invoke(this.target, new Object[0]);
            }
        } catch (Exception e) {
            log.error("执行定时任务失败", e);
        }
    }
}

5.使用

调用以上接口，参数如下。

"beanName":"任务类",
   "methodName":"任务方法",
   "params":"参数",
   "cronExpression":"表达式",

总结

到此这篇关于可视化定时任务quartz集成解析的文章就介绍到这了,更多相关quartz集成解析内容请搜索编程网以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程网！

您可能感兴趣的文档:

点击免费下载>>软考高级考试备考技巧/历年真题/备考精华资料

--结束END--

本文标题: 可视化定时任务quartz集成解析全过程

本文链接: https://www.lsjlt.com/news/169861.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

本篇文章演示代码以及资料文档资料下载

下载Word文档到电脑，方便收藏和打印～

下载Word文档

去做题

猜你喜欢

可视化定时任务quartz集成解析全过程

目录前言1.目录结构2.原理3.表结构4.整合springboot1.pom文件2.ScheduleConfig3.业务类4.运行配置5.ScheduleJob 6.Sch...

99+

2022-11-13

quartz详解 quartz源码解析 quartz集群任务调度
SpringBoot集成quartz实现定时任务详解

目录准备知识点什么是QuartzQuartz的体系结构什么是Quartz持久化实现案例 - 单实例方式实现案例 - 分布式方式后端实现前端实现测试效果准备知识点需要了解常用的Qua...

99+

2022-11-13

SpringBoot quartz定时任务 SpringBoot 定时任务 SpringBoot quartz
SpringBoot实现quartz定时任务可视化管理功能

前言在实际框架或产品开发过程中，springboot中集成quarzt方式基本是以job和trigger的bean对象方式直接硬编码完成的，例如以下代码示例。对于系统内定义的所有定...

99+

2024-04-02
springBoot项目集成quartz开发定时任务案例及注意事项

目录quartz下载、安装实战案例常见问题及解决方案quartz下载、安装 Quartz是完全由java开发的一个开源的任务日程管理系统，任务进度管理器就是一个在预先确定的时间到达时...

99+

2024-04-02
Springboot-admin整合Quartz实现动态管理定时任务的过程详解

目录boot-admin整合Quartz实现动态管理定时任务加入依赖前端整合vue页面后端整合配置类单独数据源配置调度器配置任务模板Job示例类管理功能boot-admin整合Qua...

99+

2023-05-18

Springboot-admin整合Quartz Springboot动态管理定时任务
SpringBoot日程管理Quartz与定时任务Task实现详解

目录1 Quartz核⼼概念Springboot整合Quartz1.导⼊springboot整合Quartz的starter2.定义任务Bean3.创建Quartz配置类2. Tas...

99+

2024-04-02
SpringBoot集成ShedLock实现分布式定时任务流程详解

目录一、背景二、ShedLock是什么三、落地实现1.1 引入依赖包1.2 配置数据库连接信息1.3 创建Mysql数据表1.4 配置LockProvider1.5 创建定时Job四...

99+

2023-02-24

SpringBoot ShedLock SpringBoot ShedLock分布式定时任务 SpringBoot分布式定时任务
Spring Boot集成Quartz实现定时任务的动态创建、启动、暂停、恢复、删除

一、整个 Quartz 的代码流程基本基本如下：首先需要创建我们的任务(Job)，比如取消订单、定时发送短信邮件之类的，这是我们的任务主体，也是写业务逻辑的地方。创建任务调度器(Scheduler)，这是用来调度任务的,主要用于启动...

99+

2023-09-10

spring boot java spring Quartz Powered by 金山文档
SpringBoot整合Xxl-job实现定时任务的全过程

目录前言一、部署调度中心1、项目下载2、初始化数据3、修改properties配置文件二、部署SpringBoot项目1、引入依赖2、创建配置类3、修改配置文件4、创建执行器5、启动...

99+

2024-04-02
SpringBoot整合定时任务之实现Scheduled注解的过程(一个注解全解决)

目录一、使用场景二、准备工作三、开始搭建配置配置启动项四、结果展示五、总结一、使用场景定时任务在开发中还是比较常见的,比如:定时发送邮件,定时发送信息,定时更新资源,定时更新数据等...

99+

2024-04-02
python apscheduler cron定时任务触发接口自动化巡检过程

目录python cron定时任务触发接口自动化巡检apscheduler报错：Run time of job …… next run at: &hell...

99+

2023-03-14

python定时任务 python apscheduler cron python apscheduler定时任务
Win7系统任务栏个性化时间设置教程全程图解

　　对比经典XP系统，win7 　　Win7系统任务栏个性化时间设置具体步骤：　　1、鼠标点击“开始”，选择控制面板，进入控制面板中设置。如图1 所示图1 控制面板　　2、在控制...

99+

2023-06-08

Win7 任务栏时间栏个性化任务系统
SpringBoot通过@Scheduled实现定时任务及单线程运行问题解决

目录一、开启定时任务方法二、不同定时方式的解析1.fixedDelay和fixedRate，单位是毫秒，它们的区别就是：2.cron表达式：灵活三、实现定时任务四、解决定时任务单线程...

99+

2023-02-21

springboot @scheduled实现定时任务 Springbootschedule单线程 springboot 定时任务