基于quartz的动态任务

最新推荐文章于 2023-11-10 09:44:00 发布
最新推荐文章于 2023-11-10 09:44:00 发布
阅读量792 收藏
点赞数
分类专栏： quartz 文章标签： quartz
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shjhhc/article/details/52199393
版权

quartz是一个提供定时任务的框架。任务可以直接配置在配置文件之中或者数据库里，这种无法修改的任务可以叫做静态任务，而这次写的是怎么创建动态任务，可以在项目运行中对定时任务进行创建、修改、删除等操作。
我这里是基于spring框架搭建的quartz系统。spring配置文件中配置了SchedulerFactoryBean工厂类，用于生成Scheduler对象。

<bean id="schedulerFactoryBean" class="org.springframework.scheduling.quartz.SchedulerFactoryBean" lazy-init="false">
        <property name="dataSource"><!--数据库数据源，这里的任务是配置在数据库中的-->
            <ref bean="qrtzDataSource"/>
        </property>
        <property name="autoStartup" value="true"/> <!--开发人员本机此处默认为false-->
        <property name="startupDelay" value="60" />
        <property name="applicationContextSchedulerContextKey" value="applicationContext"/>
        <property name="configLocation" value="classpath:/spring/quartz.properties"/>
    </bean>

表结构都是quartz项目提供的，我用的mysql，选取对应文件即可。
这里写图片描述

开始coding
1、首先定义一个我们需要的job的信息类

public class QuartzJobBean implements Serializable {
    private static final long serialVersionUID = 8426499555496553217L;

    public static final String CONCURRENT_IS = "1";

    public static final String CONCURRENT_NOT = "0";

    public static final String STATUS_NONE = "NONE";

    public static final String STATUS_NORMAL = "NORMAL";

    public static final String STATUS_PAUSED = "PAUSED";

    public static final String STATUS_COMPLETE = "COMPLETE";

    public static final String STATUS_ERROR = "ERROR";

    public static final String STATUS_BLOCKED = "BLOCKED";

    /** 任务id */
    private String jobId;

    /** 任务名称 */
    private String jobName;

    /** 任务分组，任务名称+组名称应该是唯一的 */
    private String jobGroup;

    /** 任务初始状态 0禁用 1启用 2删除*/
    private String jobStatus;

    /** 任务是否有状态（并发） */
    private String isConcurrent = "1";

    /** 任务运行时间表达式 */
    private String cronExpression;

    /** 任务描述 */
    private String description;

    /** 任务调用类在spring中注册的bean id，如果spingId不为空，则按springId查找 */
    private String springId;

    /** 任务调用类名，包名+类名，通过类反射调用 ，如果spingId为空，则按jobClass查找   */
    private String jobClass;

    /** 任务调用的方法名 */
    private String methodName;

    /** 启动时间 */
    private Date startTime;

    /** 前一次运行时间 */
    private Date previousTime;

    /** 下次运行时间 */
    private Date nextTime;

//getter、setter方法

2、接下来是核心任务操作类

@Component
public class QuartzJobManage {
    private static final Logger logger = LoggerFactory.getLogger(QuartzJobManage.class);

    /**
     * 添加任务
     *
     * @param scheduleJob
     */
    public void addJob(QuartzJobBean scheduleJob) throws CustomerBizException {
        try {
            if (scheduleJob == null || !QuartzJobBean.STATUS_NORMAL.equals(scheduleJob.getJobStatus()))
                throw new CustomerBizException("添加的任务不能为null并且任务的初始状态必须是[STATUS_NORMAL]");
            if (!TaskUtils.isValidExpression(scheduleJob.getCronExpression()))
                throw new CustomerBizException("任务名称[" + scheduleJob.getJobName() + "] 任务分组[" + scheduleJob.getJobGroup() + "]的时间表达式错误：" + scheduleJob.getCronExpression());
            //SpringContextUtil.getBean("schedulerFactoryBean");就是封装的这个applicationContext.getBean(name);这句代码里面有关于spring IOC的一个机制，如果你实现了spring的FactoryBean<T>接口，那你通过applicationContext.getBean(name)返回的将是getObjectType（）方法返回的对象，类型为T，详情可参见spring源码
            Scheduler scheduler = (Scheduler) SpringContextUtil.getBean("schedulerFactoryBean");
            final TriggerKey triggerKey = TriggerKey.triggerKey(scheduleJob.getJobName(), scheduleJob.getJobGroup());
            Trigger trigger = scheduler.getTrigger(triggerKey);
            if (null == trigger){
            //这是QuartzJobBean类中定义的真正要执行的任务类
                Class<? extends Job> clazz = (Class<? extends Job>) Class.forName(scheduleJob.getJobClass());
                final JobDetail jobDetail = JobBuilder.newJob(clazz).withIdentity(scheduleJob.getJobName(), scheduleJob.getJobGroup()).build();
                jobDetail.getJobDataMap().put("scheduleJob", scheduleJob);
                final CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(scheduleJob.getCronExpression());
                trigger = TriggerBuilder.newTrigger().withIdentity(triggerKey).withSchedule(scheduleBuilder).build();
                scheduler.scheduleJob(jobDetail, trigger);
            } else {
                // trigger已存在，则更新相应的定时设置
                final CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(scheduleJob.getCronExpression());
                trigger = TriggerBuilder.newTrigger().withIdentity(triggerKey).withSchedule(scheduleBuilder).build();
                scheduler.rescheduleJob(triggerKey, trigger);
            }
        } catch (SchedulerException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

/** 暂停任务
     * @param scheduleJob
     * @return
     */
    public void pauseJob(QuartzJobBean scheduleJob){
        try {
            Scheduler scheduler = (Scheduler) SpringContextUtil.getBean("schedulerFactoryBean");
            final JobKey jobKey = JobKey.jobKey(scheduleJob.getJobName(), scheduleJob.getJobGroup());
            scheduler.pauseJob(jobKey);
        } catch (SchedulerException e) {
            logger.error("任务暂停失败：", e);
        }
    }

    /**
     * 恢复任务
     * @param scheduleJob
     * @return
     */
    public void resumeJob(QuartzJobBean scheduleJob) {
        try {
            Scheduler scheduler = (Scheduler) SpringContextUtil.getBean("schedulerFactoryBean");
            final JobKey jobKey = JobKey.jobKey(scheduleJob.getJobName(), scheduleJob.getJobGroup());
            scheduler.resumeJob(jobKey);
        } catch (SchedulerException e) {
            logger.error("任务恢复失败：", e);
        }
    }

    /**
     * 删除任务
     */
    public void deleteJob(QuartzJobBean scheduleJob){
        try {
            Scheduler scheduler = (Scheduler) SpringContextUtil.getBean("schedulerFactoryBean");
            final JobKey jobKey = JobKey.jobKey(scheduleJob.getJobName(), scheduleJob.getJobGroup());
            scheduler.deleteJob(jobKey);
        } catch (SchedulerException e) {
            logger.error("任务名称[" + scheduleJob.getJobName() + "] 分组[" + scheduleJob.getJobGroup() + "] 删除失败!", e);
        }
    }

/**
     * 获取单个任务
     * @param jobName
     * @param jobGroup
     * @return
     * @throws SchedulerException
     */
    public QuartzJobBean findJob(String jobName, String jobGroup)
    {
        try
        {
            QuartzJobBean job = null;
            Scheduler scheduler = (Scheduler) SpringContextUtil.getBean("schedulerFactoryBean");
            TriggerKey triggerKey = TriggerKey.triggerKey(jobName, jobGroup);
            CronTrigger trigger = (CronTrigger)scheduler.getTrigger(triggerKey);

            JobKey jobKey = JobKey.jobKey(jobName, jobGroup);
            JobDetail jobDetail = scheduler.getJobDetail(jobKey);

            if (trigger != null && jobDetail != null)
            {
                QuartzJobBean jobExist = (QuartzJobBean)jobDetail.getJobDataMap().get("scheduleJob");
                job = new QuartzJobBean();
                job.setJobName(jobName);
                job.setJobGroup(jobGroup);
                job.setDescription("触发器:" + trigger.getKey());
                job.setNextTime(trigger.getNextFireTime()); //下次触发时间
                job.setPreviousTime(trigger.getPreviousFireTime());//上次触发时间
                job.setDescription(jobExist.getDescription());
                job.setJobClass(jobExist.getJobClass());
                job.setMethodName(jobExist.getMethodName());

                Trigger.TriggerState triggerState = scheduler.getTriggerState(trigger.getKey());
                job.setJobStatus(triggerState.name());
                if (trigger instanceof CronTrigger)
                {
                    CronTrigger cronTrigger = (CronTrigger)trigger;
                    String cronExpression = cronTrigger.getCronExpression();
                    job.setCronExpression(cronExpression);
                }
            }
            return job;
        }
        catch (Exception e)
        {
            logger.error("任务获取失败：", e);
        }
        return null;
    }
    }

3、任务执行我用的quartz的Job类，通过集成spring的QuartzJobBean类，他是一个实现了Job接口，完成了任务执行模板（模板模式）的抽象类，我们继承他实现一些自己的逻辑和规则。BaseJob 类也是一个模板，run（）方法的实现就是要执行的任务。

@Component
public abstract class BaseJob extends QuartzJobBean{

    private static final Logger logger = LoggerFactory.getLogger(BaseJob.class);

    /**
     * 供实现类运行
     * @param context 任务执行上下文
     * @throws JobExecutionException 任务执行时异常
     */
    protected abstract void run(JobExecutionContext context) throws JobExecutionException;

    /**
     * @param context 任务执行上下文
     * @throws JobExecutionException 任务执行时异常
     */
    protected void executeInternal(JobExecutionContext context) throws JobExecutionException {
        try {
            run(context);
        }
        catch (Exception e) {
            logger.error(e.toString());
        }
        finally {

        }
    }
}

4、任务实现类，举例

public class OrderPayTask extends BaseJob {
    @Override
    protected void run(JobExecutionContext context) throws JobExecutionException {
    //自己的任务实现
    }
    }

5、任务工具类

public class TaskUtils {
    private static final Logger logger = LoggerFactory.getLogger(TaskUtils.class);
/**
     * 判断cron时间表达式正确性
     * @param cronExpression
     * @return
     */
    public static boolean isValidExpression(String cronExpression){
        CronTriggerImpl trigger = new CronTriggerImpl();
        try {
            trigger.setCronExpression(cronExpression);
            final Date date = trigger.computeFirstFireTime(null);
            return date != null && date.after(new Date());
        } catch (ParseException e) {
            logger.error("时间表达式:" + cronExpression + "错误");
        }
        return false;
    }
    }

6、成功之后主要表里的数据
qrtz_job_details这里写图片描述
qrtz_job_details
这里写图片描述
qrtz_triggers
这里写图片描述

就此完结！

shjhhc
关注
专栏目录
基于Quartz的定时任务实现
FairytailRose的博客
06-26 242
基于Quartz的定时任务实现 核心:Quartz Scheduler:调度器,所有执行操作由scheduler统一管理 Trigger:设置时间,间隔,次数 JobDetail:任务的实例 Job:任务业务逻辑 依赖包 <dependency> <groupId>org.quartz-scheduler</groupId> <artifa...
基于Spring的Quartz动态定时任务增删改查
01-31
基于Spring的Quartz动态定时任务增删改查，代码简洁。后端采用SpringMvc+Spring+Mybatis+Quartz，前端采用Bootstrap框架，数据库采用MySQL；完成定时任务动态任务初始化，增删改查
quartz 动态执行定时任务
03-16
quartz 动态定时任务 根据数据库数据配置动态定时任务
基于Quartz实现动态定时任务
最新发布
Laity
11-10 3103
本文带各位学习下Quartz的基本使用及业务中的整合，包括基本概念以及如何动态地对定时任务进行CRUD，并且如何实现定时任务的持久化以及任务恢复；其中分享下本人在使用时遇到的问题，和解决方案。
quartz-动态任务开发
zhangruilinmoo
10-27 667
quartz-动态任务开发，可根据要求执行不同的任务内容
定时任务系列(3)-Quartz动态定时任务
CodeV的博客
10-17 2846
Quartz定时任务框架经常用于系统后台业务异步处理。平常我们使用时，主要是通过手工编写配置代码文件方式添加修改定时任务，然后重启系统。有时候我们需要根据业务运营需要，动态添加修改定时任务，比如添加新的定时任务、修改任务执行时间、暂停定时任务、删除定时任务等，并且监控定时任务状态，而又不想重启系统，这时就需要系统具备动态管理定时任务的功能。Quartz提供了一系列组件，支持动态管理定时任务的功能。
SpringBoot2.0整合Quartz定时任务,实现基于数据库如mysql的动态任务
12-27
在Spring Boot 2.0中整合Quartz定时任务，可以实现基于数据库如MySQL的动态任务管理，这在很多需要周期性执行任务的应用场景中非常实用。以下将详细讲解这一过程。 首先，我们要在项目的`pom.xml`文件中添加Quartz...
基于SSM+quartz的定时任务管理demo
05-10
本Demo以"基于SSM+quartz的定时任务管理"为主题，将展示如何在Spring、SpringMVC和MyBatis（SSM）框架基础上，集成Quartz作为调度引擎，实现高效灵活的定时任务管理。 **1. SSM框架简介** SSM是Spring、SpringMVC...
Springboot2-Quartz 后台可动态配置的定时任务
02-28
本项目“Springboot2-Quartz 后台可动态配置的定时任务”是基于SpringBoot 2.x版本与Quartz Scheduler整合的一个示例，它展示了如何在后台管理系统中动态地创建、更新和删除定时任务，以及监控这些任务的状态，为...
基于quartz定时任务框架.rar
08-02
在本项目中，你提供的是一个基于Quartz实现的轻量级定时任务框架，这表明它可能简化了Quartz的一些复杂性，使之更适合小型或中型应用的需求。 **Quartz核心概念** 1. **Job**：在Quartz中，Job是执行具体任务的...
spring+quartz实现动态设置定时任务
10-28
spring+quartz实现动态设置定时任务，自己的例子+心得+sql语句
quartz小项目
03-13
quartz小项目,适合每一位java开发人员，希望能帮助每一位开发人员。。
Spingboot+Quartz基于数据库的作业任务调度
12-03
Spingboot+Quartz实现定时任务作业调度，并基于数据库对任务作业进行配置，可以实现灵活地更新和删除定时任务。
QUARTZ项目实练
11-07
通过数据表配置service方法类以及cron表达式，实现quartz定时轮询执行
web项目集成quartz实例（9个）
06-28
web项目集成quartz，从简单到复杂，1-9分开展示quartz的集成到配置，希望和大家一起学习一下
Spring任务调度-基于Quartz
心情夜雪
03-22 757
任务调度图解： 1.继承JobDetail类的方式 Java代码 public class QuartzJob extends QuartzJobBean { private String command; public void setCommand(String command) { th
springboot之quartz动态可控定时任务
qq_14926283的博客
10-19 910
Quartz是一个开源的任务调度框架，可以用来实现定时任务的调度，如定时发送邮件、定时备份数据等。Quartz具有很高的可靠性和灵活性，支持集群部署和分布式调度，并且提供了丰富的API和插件，可以轻松实现复杂的调度需求。Quartz的工作原理是通过Job和Trigger两个核心概念来实现的，Job是具体需要执行的任务，Trigger用来触发任务的执行时机。在Quartz中，可以通过定义各种Trigger来实现不同的调度策略，如简单调度、Cron调度等。
SpringBoot集成Quartz 2.3.1动态管理定时任务
weipinggg的博客
09-23 2111
我写了一个简单的Demo项目，有需要的文末可获取项目github地址，该项目我会一直保持更新。基于quartz2.3.1实现动态管理定时任务。使用swagger实现接口文档。前后端统一使用JSON格式交互。使用Hutool工具类直接连接数据库，避免Job任务中不能使用Autowired问题。swagger文档如下图：后续文章创建JobDetail（JobBuilder详解）创建CronTrigger（TriggerBuilder详解）
Quartz：动态控制定时任务
程序员无羡的博客
04-28 617
Quartz：动态控制定时任务
Spring整合Quartz实现动态任务调度
"本文主要介绍了如何在Spring框架中集成Quartz库，用于实现动态任务调度。Quartz是一个强大的作业调度框架，允许开发者根据时间间隔安排任务。在Spring中结合Quartz，可以实现更灵活的定时任务管理。文中提到了四个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值