使用Spring的quartz实现一个简单定时任务调度管理系统，附原理(简单易懂)

最新推荐文章于 2024-04-26 20:19:53 发布
最新推荐文章于 2024-04-26 20:19:53 发布
阅读量1.8k 收藏 13
点赞数 3
分类专栏： javaee框架 文章标签： spring java 后端 quartz
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45826772/article/details/123167814
版权

使用Spring的quartz实现一个简单定时任务调度管理系统

1.效果图（前端做的太low，所以结合了swagger2框架调试接口）

1.1:页面效果图
1.2:接口文档图：

2.主要功能

  1. 定时任务状态的启动、停止、恢复、立即执行一次。
  2. 定时任务执行周期的动态修改。
  3. 定时任务的增删改。

3.功能实现

3.3:数据库表结构：(暂时没加日志)
CREATE TABLE `job` (
  `id` int(11) NOT NULL AUTO_INCREMENT COMMENT 'id',
  `job_name` varchar(255) NOT NULL COMMENT '任务名称',
  `job_group` varchar(255) NOT NULL COMMENT '任务组名',
  `status` int(255) NOT NULL COMMENT '任务状态:0=正常,1=暂停',
  `trigger_name` varchar(255) NOT NULL COMMENT 'trigger名称',
  `trigger_group` varchar(255) NOT NULL COMMENT 'trigger组名',
  `invoke_target` varchar(255) NOT NULL COMMENT '调用目标字符串',
  `concurrent` varchar(255) NOT NULL COMMENT '并发执行 0=允许,1=禁止',
  `cron_expression` varchar(255) NOT NULL COMMENT 'cron执行表达式',
  `misfire_policy` varchar(255) NOT NULL COMMENT '计划策略 0=默认,1=立即触发执行,2=触发一次执行,3=不触发立即执行',
  `create_time` datetime DEFAULT NULL COMMENT '创建时间',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=6 DEFAULT CHARSET=utf8mb4;
3.2:添加依赖

（项目是使用springboot构建，以下只展示主要用到的依赖）

		<!-- 定时任务 -->
        <dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz</artifactId>
            <version>2.3.2</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
            <version>5.3.12</version>
        </dependency>
        <!-- 流处理 -->
        <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
            <version>2.6</version>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.10</version>
        </dependency>
        <!--    swagger2    -->
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger2</artifactId>
            <version>2.9.2</version>
        </dependency>
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger-ui</artifactId>
            <version>2.9.2</version>
        </dependency>
        <!--  swagger2第三方ui  -->
        <dependency>
            <groupId>com.github.xiaoymin</groupId>
            <artifactId>swagger-bootstrap-ui</artifactId>
            <version>1.9.6</version>
        </dependency>
3.2:代码实现

省略Controller、mapper、实体类和接口代码

3.2.1: 任务调度通用常量代码
public class ScheduleConstants {
    /** jobKey前缀标识 */
    public static final String TASK_CLASS_NAME = "TASK_CLASS_NAME";

    /** 执行目标key */
    public static final String TASK_PROPERTIES = "TASK_PROPERTIES";

    /** 默认 */
    public static final String MISFIRE_DEFAULT = "0";

    /** 立即触发执行 */
    public static final String MISFIRE_IGNORE_MISFIRES = "1";

    /** 触发一次执行 */
    public static final String MISFIRE_FIRE_AND_PROCEED = "2";

    /** 不触发立即执行 */
    public static final String MISFIRE_DO_NOTHING = "3";
}
3.2.2: 调用quartz抽象类
public abstract class AbstractQuartzJob implements Job {

    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        MyJob myJob = new MyJob();
        copyBeanProp(myJob, jobExecutionContext.getMergedJobDataMap().get(ScheduleConstants.TASK_PROPERTIES));
        try {
            //执行定时任务
            doExecute(jobExecutionContext,myJob);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    /**
     * 执行方法，由子类重载
     *
     * @param context 工作执行上下文对象
     * @param myJob 系统计划任务
     * @throws Exception 执行过程中的异常
     */
    protected abstract void doExecute(JobExecutionContext context, MyJob myJob) throws Exception;

    /**
     * Bean属性复制工具方法。
     *
     * @param dest 目标对象
     * @param src  源对象
     */
    public static void copyBeanProp(Object dest, Object src) {
        try {
            copyProperties(src, dest);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}
3.2.3: job任务类

Job任务累分为俩种:允许并发执行和禁止并非执行

/**
 * 定时任务处理（禁止并发执行）
 */
@DisallowConcurrentExecution
public class QuartzDisallowConcurrentExecution extends AbstractQuartzJob
{
    @Override
    protected void doExecute(JobExecutionContext context, MyJob job) throws Exception
    {
        JobInvokeUtil.invokeMethod(job);
    }
}
/**
 * 定时任务处理（允许并发执行）
 */
public class QuartzJobExecution extends AbstractQuartzJob
{
    @Override
    protected void doExecute(JobExecutionContext context, MyJob myJob) throws Exception
    {
        JobInvokeUtil.invokeMethod(myJob);
    }
}
3.2.4: Spring工具类
@Component
public final class SpringUtils implements BeanFactoryPostProcessor{
	/**
     * Spring应用上下文环境
     */
    private static ConfigurableListableBeanFactory beanFactory;
    
    /**
     * 获取对象
     *
     * @param name
     * @return Object 一个以所给名字注册的bean的实例
     * @throws BeansException
     */
    @SuppressWarnings("unchecked")
    public static <T> T getBean(String name) throws BeansException {
        return (T) beanFactory.getBean(name);
    }
3.2.5: 任务执行工具工具类
public class JobInvokeUtil {

    /**
     * 调用任务方法
     *
     * @param bean         目标对象
     * @param methodName   方法名称
     * @param methodParams 方法参数
     */
    private static void invokeMethod(Object bean, String methodName, List<Object[]> methodParams)
            throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException,
            InvocationTargetException {
        if (isNotNull(methodParams) && methodParams.size() > 0) {
            Method method = bean.getClass().getDeclaredMethod(methodName, getMethodParamsType(methodParams));
            method.invoke(bean, getMethodParamsValue(methodParams));
        } else {
            Method method = bean.getClass().getDeclaredMethod(methodName);
            method.invoke(bean);
        }
    }

    /**
     * 执行方法
     *
     * @param job 系统任务
     */
    public static void invokeMethod(MyJob job) throws Exception {
        String invokeTarget = job.getInvokeTarget();
        //获取bean的名称
        String beanName = getBeanName(invokeTarget);
        //获取方法名
        String methodName = getMethodName(invokeTarget);
        List<Object[]> methodParams = getMethodParams(invokeTarget);

        if (!isValidClassName(beanName)) {
            Object bean = SpringUtils.getBean(beanName);
            invokeMethod(bean, methodName, methodParams);
        } else {
            Object bean = Class.forName(beanName).newInstance();
            invokeMethod(bean, methodName, methodParams);
        }
    }

    /**
     * 获取bean名称
     *
     * @param invokeTarget 目标字符串
     * @return bean名称
     */
    public static String getBeanName(String invokeTarget) {
        String beanName = StringUtils.substringBefore(invokeTarget, "(");
        return StringUtils.substringBeforeLast(beanName, ".");
    }

    /**
     * 获取bean中的方法
     *
     * @param invokeTarget 目标字符串
     * @return method方法
     */
    public static String getMethodName(String invokeTarget) {
        String methodName = StringUtils.substringBefore(invokeTarget, "(");
        return StringUtils.substringAfterLast(methodName, ".");
    }

    /**
     * 校验是否为为class包名
     *
     * @param invokeTarget 名称
     * @return true是 false否
     */
    public static boolean isValidClassName(String invokeTarget) {
        return StringUtils.countMatches(invokeTarget, ".") > 1;
    }

    /**
     * 获取method方法参数相关列表
     *
     * @param invokeTarget 目标字符串
     * @return method方法相关参数列表
     */
    public static List<Object[]> getMethodParams(String invokeTarget) {
        String methodStr = StringUtils.substringBetween(invokeTarget, "(", ")");
        if (StringUtils.isEmpty(methodStr)) {
            return null;
        }
        String[] methodParams = methodStr.split(",");
        List<Object[]> classs = new LinkedList<>();
        for (int i = 0; i < methodParams.length; i++) {
            String str = StringUtils.trimToEmpty(methodParams[i]);
            // String字符串类型，包含'
            if (StringUtils.contains(str, "'")) {
                classs.add(new Object[]{StringUtils.replace(str, "'", ""), String.class});
            }
            // boolean布尔类型，等于true或者false
            else if (StringUtils.equals(str, "true") || StringUtils.equalsIgnoreCase(str, "false")) {
                classs.add(new Object[]{Boolean.valueOf(str), Boolean.class});
            }
            // long长整形，包含L
            else if (StringUtils.containsIgnoreCase(str, "L")) {
                classs.add(new Object[]{Long.valueOf(StringUtils.replaceIgnoreCase(str, "L", "")), Long.class});
            }
            // double浮点类型，包含D
            else if (StringUtils.containsIgnoreCase(str, "D")) {
                classs.add(new Object[]{Double.valueOf(StringUtils.replaceIgnoreCase(str, "D", "")), Double.class});
            }
            // 其他类型归类为整形
            else {
                classs.add(new Object[]{Integer.valueOf(str), Integer.class});
            }
        }
        return classs;
    }

    /**
     * 获取参数值
     *
     * @param methodParams 参数相关列表
     * @return 参数值列表
     */
    public static Object[] getMethodParamsValue(List<Object[]> methodParams) {
        Object[] classs = new Object[methodParams.size()];
        int index = 0;
        for (Object[] os : methodParams) {
            classs[index] = (Object) os[0];
            index++;
        }
        return classs;
    }

    /**
     * 获取参数类型
     *
     * @param methodParams 参数相关列表
     * @return 参数类型列表
     */
    public static Class<?>[] getMethodParamsType(List<Object[]> methodParams) {
        Class<?>[] classs = new Class<?>[methodParams.size()];
        int index = 0;
        for (Object[] os : methodParams) {
            classs[index] = (Class<?>) os[1];
            index++;
        }
        return classs;
    }

    /**
     * * 判断一个对象是否非空
     *
     * @param object Object
     * @return true：非空 false：空
     */
    public static boolean isNotNull(Object object) {
        return object == null;
    }
}
3.2.6: Schedule工具类
public class ScheduleUtil {

    /**
     * 得到job任务类
     *
     * @param myJob 执行计划
     * @return 具体执行任务类
     */
    private static Class<? extends Job> getQuartzJobClass(MyJob myJob) {
        boolean isConcurrent = "0".equals(myJob.getConcurrent());
        return isConcurrent ? QuartzJobExecution.class : QuartzDisallowConcurrentExecution.class;
    }


    public static void intSchedule(Scheduler scheduler, MyJob myJob) throws Exception {

        //1.创建JobDetail
        JobDetail jobDetail = JobBuilder.newJob(getQuartzJobClass(myJob))
                .withIdentity(getJobKey(myJob.getId(), myJob.getJobGroup()))
                .build();

        //1.1绑定传递参数
        jobDetail.getJobDataMap().put(ScheduleConstants.TASK_PROPERTIES, myJob);

        //2.cron表达式调度构建器
        CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule(myJob.getCronExpression());
        cronScheduleBuilder = handleCronScheduleMisfirePolicy(myJob, cronScheduleBuilder);

        
        //3.按照cronExpression表达式构建一个新的trigger
        CronTrigger trigger = TriggerBuilder.newTrigger()
                .withIdentity(getTriggerKey(myJob.getId(),
                        myJob.getJobGroup()))
                .withSchedule(cronScheduleBuilder)
                .build();

        // 4.判断是否存在
        if (scheduler.checkExists(getJobKey(myJob.getId(), myJob.getJobGroup()))) {
            // 防止创建时存在数据问题 先移除，然后在执行创建操作
            scheduler.deleteJob(getJobKey(myJob.getId(), myJob.getJobGroup()));
        }

        // 5.注册任务和定时器
        scheduler.scheduleJob(jobDetail, trigger);

        // 6.暂停任务
        //判断定时任务状态 状态为1 暂停
        if (myJob.getStatus().equals("1")) {
            scheduler.pauseJob(getJobKey(myJob.getId(), myJob.getJobGroup()));
        }
    }

    /**
     * 构建任务键对象
     */
    public static JobKey getJobKey(Long jobId, String jobGroup) {
        return JobKey.jobKey(ScheduleConstants.TASK_CLASS_NAME + jobId, jobGroup);
    }

    /**  构建任务触发对象 */
    public static TriggerKey getTriggerKey(Long jobId, String jobGroup) {
        return TriggerKey.triggerKey(ScheduleConstants.TASK_CLASS_NAME + jobId, jobGroup);
    }

    /**
     * 设置定时任务策略
     */
    public static CronScheduleBuilder handleCronScheduleMisfirePolicy(MyJob myJob, CronScheduleBuilder cb)
            throws Exception {
        switch (myJob.getMisfirePolicy()) {
            case ScheduleConstants.MISFIRE_DEFAULT:
                return cb;
            case ScheduleConstants.MISFIRE_IGNORE_MISFIRES:
                return cb.withMisfireHandlingInstructionIgnoreMisfires();
            case ScheduleConstants.MISFIRE_FIRE_AND_PROCEED:
                return cb.withMisfireHandlingInstructionFireAndProceed();
            case ScheduleConstants.MISFIRE_DO_NOTHING:
                return cb.withMisfireHandlingInstructionDoNothing();
            default:
                throw new Exception("参数有问题" + myJob.getMisfirePolicy());
        }
    }
}
3.2.6: JobService类
@Service
public class JobServiceImpl implements JobService {

    @Autowired
    private Scheduler scheduler;

    @Autowired
    private JobMapper jobMapper;

    /**
     * 初始化
     * @throws SchedulerException
     */
    @PostConstruct
    public void intJob() throws SchedulerException {
        List<MyJob> myJobs = jobMapper.queryQuartz();
        //先清理缓存
        scheduler.clear();
        //创建任务
        myJobs.forEach(myJob -> {
            try {
                ScheduleUtil.intSchedule(scheduler,myJob);
            } catch (SchedulerException e) {
                e.printStackTrace();
            } catch (Exception e) {
                e.printStackTrace();
            }
        });
    }

    /**
     * 启动一次任务
     * @throws SchedulerException
     */
    @Override
    public void runJob(Long id) throws SchedulerException {
        MyJob myJob = jobMapper.queryJobById(id);
        JobDataMap dataMap = new JobDataMap();
        //设置参数
        dataMap.put(ScheduleConstants.TASK_PROPERTIES, myJob);
        scheduler.triggerJob(ScheduleUtil.getJobKey(myJob.getId(), myJob.getJobGroup()), dataMap);
    }

    /**
     * 暂停任务
     * @throws SchedulerException
     */
    @Override
    public void stopJob(Long id) throws SchedulerException {
        MyJob myJob = jobMapper.queryJobById(id);
        scheduler.pauseJob(ScheduleUtil.getJobKey(myJob.getId(), myJob.getJobGroup()));
    }

    /**
     * 恢复任务
     * @throws SchedulerException
     */
    @Override
    public void resumeJob(Long id) throws SchedulerException {
        MyJob myJob = jobMapper.queryJobById(id);
        scheduler.resumeJob(ScheduleUtil.getJobKey(myJob.getId(), myJob.getJobGroup()));
    }

    /**
     * 删除任务
     * @throws SchedulerException
     */
    @Override
    public void deleteJob(Long id) throws SchedulerException {
    	//删除任务
        MyJob myJob = jobMapper.queryJobById(id);
        scheduler.deleteJob(ScheduleUtil.getJobKey(myJob.getId(), myJob.getJobGroup()));
    	//删除数据
    	MyJob myJob = scheduleMapper.deleteQuartzById(id);
        //更新任务
        List<MyJob> jobs = jobMapper.queryJob();
        //先清理缓存
        scheduler.clear();
        jobs.forEach(j -> {
            try {
                ScheduleUtil.intSchedule(scheduler,j);
            } catch (SchedulerException e) {
                e.printStackTrace();
            } catch (Exception e) {
                e.printStackTrace();
            }
        });
    }
	/**
     * 更新任务
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void updateSchedulerJob(MyJob myJob) throws Exception {
    	//更新数据
        scheduleMapper.updateQuartzById(myJob.getId());
        // 判断是否存在
        JobKey jobKey = ScheduleUtil.getJobKey(myJob.getId(), myJob.getJobGroup());
        if (scheduler.checkExists(jobKey)){
            // 防止创建时存在数据问题 先移除，然后在执行创建操作
            scheduler.deleteJob(jobKey);
        }
        ScheduleUtil.intSchedule(scheduler,myJob);
    }
}

4.使用方法

在数据库中增加两条如下数据
在这里插入图片描述
编写TaskService

//注意这里的bean名称
@Service("test")
public class TaskService {
	//注意这里的方法名称 这俩个对应数据库中invoke_target字段
    public void test(){
        System.err.println("task测试成功");
    }
    public void testParam(String params){
        System.out.println(params);
        System.err.println("task测试成功");
    }
}

任务会通过反射调用这里的方法，具体看原理如下分析

5.原理

数据库字段的使用地方：
id、job_name、job_group、trigger_name、trigger_group、concurrent、cron_expression、misfire_policy这些字段在定时任务初始化时被当作生成jobkey和其他条件使用。
iid、job_name、nvoke_target这些字段在定时任务调度时被当作生成jobkey和调用自建方法的条件使用

第一步：动态初始化定时任务

在这里插入图片描述
初始化的每个任务都会根据数据库的数据生成自己的JobKey。(JobKey根据id和常量生成的)
getJobKey()是生成jobkey的方法
在这里插入图片描述

第二步：动态定时任务的调度

当用户在管理平台操作执行一次定时任务时，会拿着id传到后端，后端将任务数据查出来后，并使用数据生成对于的JobKey，执行对应jobkey的任务。
在这里插入图片描述
接下来定时任务会调用我们实现的Job接口中的execute方法
在这里插入图片描述
在这里插入图片描述
最后一步就是根据数据通过反射调用当时写好的方法
在这里插入图片描述
注意：上面方法处理的数据是数据库中的invoke_target字段，小数点前缀是Bean名称，后缀是方法名

5.总结

通过以上的学习，进一步加强了对spring的认知，太强大了。

科杰智能制造
关注
  • 3
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
人工智能-项目实践-管理系统-定时任务管理系统
07-12
项目简介 使用Go语言开发的轻量级定时任务集中调度和管理系统, 用于替代Linux-crontab 查看文档 原有的延时任务拆分为独立项目延迟队列 功能特性 Web界面管理定时任务 crontab时间表达式, 精确到秒 任务执行失败可重试 任务执行超时, 强制结束 任务依赖配置, A任务完成后再执行B任务 账户权限控制 任务类型 shell任务 在任务节点上执行shell命令, 支持任务同时在多个节点上运行 HTTP任务 访问指定的URL地址, 由调度器直接执行, 不依赖任务节点 查看任务执行结果日志 任务执行结果通知, 支持邮件、Slack、Webhook
Spring Boot 实现定时任务动态管理，太爽了！
Java技术栈，分享最主流的Java技术
06-16 1335
SpringBoot的定时任务的加强工具，实现对SpringBoot原生的定时任务进行动态管理,完全兼容原生@Scheduled注解,无需对原本的定时任务进行修改。版权声明：本文为CSDN博主「敲代码的旺财」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。增强器实现的整体思路与SpringAop的思路一致，实现没有Aop复杂。(2) 使用后处理器拦截SpringBoot原本的定时任务。(4) cglib动态代理实现。(5) 定时任务执行器实现。(6) 增强器代理逻辑。
毫秒级精度计划任务管理、系统运维管理、定时执行任务、定时任务执行、任务定时执行软件 —— 定时执行专家
热门推荐
boom's works
06-25 31万+
《定时执行专家》—— 官方安装教程。《定时执行专家》是一款制作精良、功能强大、毫秒精度、专业级的定时任务执行软件。软件具有 23 种【任务类型】、12 种【触发器】触发方式，并且全面支持界面化【Cron表达式】设置。软件采用多线程并发方式检测任务触发和任务执行，能够达到毫秒级的执行精度，可以同时支持50个以上任务的毫秒级触发。
java网上爬虫和定时任务
01-07
网上爬虫 爬去指定网站 定时抓取，可以抓取明细页面内容，基于ruoyi的quartz的定时任务抓取
Linux[crontab命令]–管理定时任务
Charge8的博客
10-11 1285
Linux[crontab命令]–管理定时任务
基于SpringBoot+Vue+Quartz构建分布式任务调度系统
05-02
在我们的日常开发中，各种大型系统的开发少不了任务调度，简单的单机任务调度已经满足不了我们的系统需求，复杂的任务会让程序猿头疼， 所以急需一套专门的任务管理系统帮助我们去管理定时任务,本课程采用时下最火的技术架构，SpringBboot2.0+Vue.js+Quartz2.2完成一个复杂任务的管理系统，通过该系统可以管理我们日常各种任务，包括单任务，复杂拓扑结构任务等等。本课程带大家实现一个任务调度系统，该系统可以直接用到生产环境，其商业价值极高。该系统是一个完整可用的系统，可以满足大部分的任务调度管理，同时有任务输出监控，开发人员可以实时查看任务执行情况，非常的强大。当然大家可以根据自己公司的情况继续扩展相关功能。学完该课程，大家可以熟练掌握、深入理解和使用SpringBoot，Quartz，Vue.js等技术。课程所用到的开发环境开发工具:IDEA、WebStorm课程包含的技术：SpringBoot2.0.2.RELEASEMaven、JPA、Quartz2.2.3多线程、队列Vue.JS、Webpack、Nodejs等企业一线架构师讲授，代码在老师的指导下企业可以复用，提供企业解决方案。  版权归作者所有，盗版将进行法律维权。 
定时任务-异常日志（可针对一个集合数据中的单条数据进行记录异常日志，不影响其它数据）
weixin_45077845的博客
12-10 768
描述 我们在部署系统开启定时任务之后，当定时任务的业务代码模块出现异常，我们往往不能及时查看，还必须在服务器的log日志文件里查找，这对于运维来说极其不方便。故需要一个能及时捕捉定时任务异常的功能，并能在后台界面显示。参考若依系统定时任务模块代码 也会存在对一个集合的数据遍历处理，却因为该集合的一条数据异常导致整个集合数据事务回滚的情况，以下内容也针对这种情况进行改善。 工具类 AbstractQuartzJob 在之前的定时任务中，我们都是通过对每一个定时任务指定的类实现定时任务的接口去执行业务代
基于Spring+Quartz的分布式任务调度（原理剖析、二次开发）
05-02
Quartz是OpenSymphony开源组织在Job scheduling领域又一个开源项目，它可以与J2EE与J2SE应用程序相结合也可以单独使用。Quartz可以用来创建简单或为运行十个，百个，甚至是好几万个Jobs这样复杂的程序。Jobs可以做成标准的Java组件或 EJBs。 Quartz的优势： 1、Quartz是一个任务调度框架(库)，它几乎可以集成到任何应用系统中。 2、Quartz是非常灵活的，它让您能够以最“自然”的方式来编写您的项目的代码，实现您所期望的行为 3、Quartz是非常轻量级的，只需要非常少的配置 —— 它实际上可以被跳出框架来使用，如果你的需求是一些相对基本的简单的需求的话。 4、Quartz具有容错机制，并且可以在重启服务的时候持久化（”记忆”）你的定时任务，你的任务也不会丢失。 5、可以通过Quartz，封装成自己的分布式任务调度，实现强大的功能，成为自己的产品。6、有很多的互联网公司也都在使用Quartz。比如美团 Spring是一个很优秀的框架，它无缝的集成了Quartz，简单方便的让企业级应用更好的使用Quartz进行任务的调度。   课程说明：在我们的日常开发中，各种大型系统的开发少不了任务调度，简单的单机任务调度已经满足不了我们的系统需求，复杂的任务会让程序猿头疼， 所以急需一套专门的框架帮助我们去管理定时任务，并且可以在多台机器去执行我们的任务，还要可以管理我们的分布式定时任务。本课程从Quartz框架讲起，由浅到深，从使用到结构分析，再到源码分析，深入解析Quartz、Spring+Quartz，并且会讲解相关原理， 让大家充分的理解这个框架和框架的设计思想。由于互联网的复杂性，为了满足我们特定的需求，需要对Spring+Quartz进行二次开发，整个二次开发过程都会进行讲解。Spring被用在了越来越多的项目中, Quartz也被公认为是比较好用的定时器设置工具，学完这个课程后，不仅仅可以熟练掌握分布式定时任务，还可以深入理解大型框架的设计思想。
Quartz定时任务的使用
m0_46561911的博客
11-14 1508
quartz定时任务
SpringBoot Quartz使用
Andy's Blog
10-20 643
Pom中引用quartz <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLoca...
基于Java的一个简单的定时任务调度管理系统.zip
02-27
基于Java的一个简单的定时任务调度管理系统.zip 分享一个简单的定时任务调度管理系统 项目基于springboot quartz mybatis开发 1.可以支持定时任务的管理调度,实现定时任务的动态设置和统一管理; 2.目前比较简单的...
Spring 中使用Quartz实现任务调度
08-31
主要介绍了Spring 中使用Quartz实现任务调度，Spring中使用Quartz 有两种方式，感兴趣的小伙伴们可以参考一下。
spring boot整合quartz实现多个定时任务的方法
08-28
主要介绍了spring boot整合quartz实现多个定时任务的方法，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
spring-quartz:使用 SpringBoot + Quartz + Beetl 实现一个 Spring 管理，自主可控的定时任务调度脚手架
05-10
SpringBoot + Quartz 实现完全可控的定时任务调度，可自定义定时任务具体的实现类 ...使用私有静态 scheduler 作为管理者，使用 scheduler 的方法来获取某一个任务的所有信息 使用 scheduler.getTri
基于Spring Boot和Quartz的CRUD任务管理系统设计源码
04-17
本项目是基于Spring Boot和Quartz开发的CRUD任务管理系统设计源码，主要使用Java进行开发。项目共包含1637个文件，其中SVG矢量图文件760个，PNG图片文件640个，CSS样式文件56个，JavaScript源代码文件25个，SQL文件...
SpringBoot项目打包分离高阶操作
Record Little
04-23 630
虽然传输jar包 比较大，但是安全性、稳定性比较高，不需要关注pom.xml 添加了新的依赖、更新了版本号等等影响版本功能的操作。关注maven的特性， profiles即可满足， 根据不同的activation 状态，激活不同的build操作。每次修改一小部分代码或仅仅更新某个依赖jar包时，都需要重新进行整个项目的构建、打包、上传和部署。但是当你的项目趋于稳定，只有业务上的逻辑变更时，如果使用分离版本，可以加快迭代、更新的速度。弊端： 需要配置IDE命令，修改依赖时需要同时修改2处。
mysql-connector-java和spring-boot-starter-jdbc和mybatis-spring-boot-start
xzy的博客
04-23 964
JDBC是使用java语言操作mysql数据库的规范，java语言必须按照这个规范写才可以操作mysql数据库。
SpringCloudAlibaba：2.1nacos
最新发布
m0_63040701的博客
04-26 708
Nacos是阿里巴巴开源的服务注册中心以及配置中心Nacos=注册中心Eureka + 服务配置Config + 服务总线Bus。
SpringBoot JPA使用
gochenguowei的博客
04-25 924
是 Spring 框架提供的一个模块，用于简化与关系型数据库的交互和数据访问。它基于JPA（Java Persistence API）标准，并提供了一组易于使用的API和工具，帮助开发人员更轻松地进行数据库操作。通过Spring Data JPA，开发人员可以通过编写简洁的代码来执行常见的 CRUD 操作，同时还支持高级查询、分页、事务管理等功能。它的目标是提供一种更简单、更高效的方式来处理数据库操作，减少开发人员的工作量，并提高应用程序的可维护性和可扩展性。
quartz动态定时任务
09-10
### 回答1： Quartz是一个强大的开源调度框架，可以用来实现各种类型的定时任务，包括动态定时任务。下面是一个基于Spring框架和Quartz的动态定时任务的示例： 1. 引入相关依赖 在项目的pom.xml文件中添加以下依赖： ```xml <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context-support</artifactId> <version>${spring.version}</version> </dependency> <dependency> <groupId>org.quartz-scheduler</groupId> <artifactId>quartz</artifactId> <version>${quartz.version}</version> </dependency> ``` 2. 配置Quartz 在Spring的配置文件中配置Quartz，包括调度器、触发器和任务等。以下是一个简单的配置示例： ```xml <bean id="schedulerFactoryBean" class="org.springframework.scheduling.quartz.SchedulerFactoryBean"> <property name="triggers"> <list> <ref bean="simpleTrigger" /> </list> </property> </bean> <bean id="simpleTrigger" class="org.springframework.scheduling.quartz.SimpleTriggerFactoryBean"> <property name="jobDetail" ref="jobDetail" /> <property name="repeatInterval" value="5000" /> <property name="startDelay" value="1000" /> </bean> <bean id="jobDetail" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean"> <property name="targetObject" ref="myTask" /> <property name="targetMethod" value="run" /> </bean> <bean id="myTask" class="com.example.MyTask" /> ``` 上面的配置中，定义了一个触发器simpleTrigger，它关联了一个任务jobDetail，任务的实现类是MyTask，它的run方法将会被调用。 3. 编写动态任务的代码 在需要动态创建任务的地方，可以使用以下代码： ```java @Autowired private SchedulerFactoryBean schedulerFactoryBean; public void scheduleJob(String jobName, String groupName, String cronExpression) throws SchedulerException { JobDetail jobDetail = JobBuilder.newJob(MyTask.class) .withIdentity(jobName, groupName) .build(); CronTrigger trigger = TriggerBuilder.newTrigger() .withIdentity(jobName, groupName) .withSchedule(CronScheduleBuilder.cronSchedule(cronExpression)) .build(); Scheduler scheduler = schedulerFactoryBean.getScheduler(); scheduler.scheduleJob(jobDetail, trigger); } ``` 上面的代码中，使用JobBuilder和TriggerBuilder创建任务和触发器，然后将它们通过Scheduler的scheduleJob方法添加到调度器中。 4. 动态修改任务的执行时间 如果需要动态修改任务的执行时间，可以使用以下代码： ```java public void rescheduleJob(String jobName, String groupName, String cronExpression) throws SchedulerException { TriggerKey triggerKey = new TriggerKey(jobName, groupName); CronTrigger oldTrigger = (CronTrigger) scheduler.getTrigger(triggerKey); if (oldTrigger == null) { return; } CronTrigger newTrigger = TriggerBuilder.newTrigger() .withIdentity(jobName, groupName) .withSchedule(CronScheduleBuilder.cronSchedule(cronExpression)) .build(); scheduler.rescheduleJob(triggerKey, newTrigger); } ``` 上面的代码中，使用TriggerKey获取到原有的触发器，然后使用TriggerBuilder创建新的触发器，最后通过Scheduler的rescheduleJob方法更新触发器。 ### 回答2： Quartz是一个开源的Java任务调度框架，它提供了强大的动态定时任务管理功能。使用Quartz，我们可以轻松地创建、调度和管理定时任务。 Quartz支持多种触发器类型，如简单触发器和Cron表达式触发器，这使得我们能够根据时间、日期、周几等条件来触发任务的执行。同时，Quartz还支持设置任务的优先级、重复执行次数和间隔时间等属性，以满足不同任务需求。 Quartz的动态定时任务管理功能是指可以在运行时动态地添加、修改和删除定时任务。通过Quartz的API，我们可以方便地创建和配置任务，然后将其提交给Quartz进行管理。当任务需要被修改或删除时，我们只需要更新相应的配置信息即可，不需要重新启动应用程序。 动态定时任务的管理有助于实现任务的动态调度和灵活性。我们可以根据业务需求，动态地添加新的定时任务。例如，我们可以实现一个任务调度系统，允许用户按照自定义的触发条件和执行逻辑来添加定时任务。这样一来，用户可以根据业务需要，随时添加或删除任务，而不需要修改程序代码。 总而言之，Quartz的动态定时任务管理功能为我们提供了一种便捷的方式来创建、调度和管理任务。它的灵活性和易用性使得我们能够更好地满足业务需求，实现高效的任务调度。 ### 回答3： Quartz是一个功能强大的开源的Java调度框架，用于实现各种复杂的调度需求。它支持静态和动态的定时任务。 动态定时任务是指在应用程序运行过程中动态添加、修改和删除定时任务。Quartz提供了灵活的API和丰富的功能，使得动态定时任务的管理变得简单。 首先，我们需要创建一个调度器(Scheduler)对象，它是Quartz框架的核心组件。调度器负责管理和执行所有的定时任务。然后，我们可以使用JobDetail对象定义要执行的任务，以及任务的相关属性。接着，我们可以创建一个触发器(Trigger)对象，用于指定任务的触发时间和频率。 当我们需要动态地添加或修改定时任务时，可以使用调度器的addJob()方法将任务添加到调度器中。这样，调度器会根据定义的触发器来执行任务。如果需要删除某个任务，可以使用调度器的deleteJob()方法。 动态定时任务在很多场景下都非常有用。例如，我们可以根据用户的需求，动态地调整定时任务的执行时间和频率。另外，如果某个任务在执行过程中出现了问题，我们可以通过动态修改任务的相关属性来进行修复，而不需要停止整个应用程序。 总之，Quartz动态定时任务的特点是灵活、可扩展和易于管理。它可以帮助我们实现各种复杂的调度需求，并且可以根据应用程序的运行情况动态地添加、修改和删除定时任务。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

科杰智能制造

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值