spring+quartz动态定时器设置也可以动态通过反射设置支持多种

最新推荐文章于 2024-08-19 14:51:10 发布
最新推荐文章于 2024-08-19 14:51:10 发布
阅读量1.1k 收藏
点赞数
分类专栏： 后台 文章标签： spring quartz 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010737411/article/details/65633959
版权

创建表结构 《数据库Oracle》：

 DROP TABLE t_ctrigger;

create sequence s_t_ctrigger
minvalue 1
maxvalue 999999999999999999999999999
start with 1
increment by 1
cache 10;

CREATE TABLE t_ctimetrigger(
  id number,
  triggername varchar2(50) NOT NULL,
  jobdetailname varchar2(50) NOT NULL,
  cronexpression varchar2(50) NOT NULL,
  targetobject varchar2(50) NOT NULL,
  methodname varchar2(50) NOT NULL,
  concurrent char(10)  DEFAULT '0' NOT NULL,
  state char(10)  DEFAULT '1' NOT NULL,
  isspringbean char(10)  DEFAULT '0' NOT NULL,
  readme varchar2(100) DEFAULT NULL,
  reserved1 varchar2(50) DEFAULT NULL,
  reserved2 varchar2(50) DEFAULT NULL,
  reserved3 varchar2(50) DEFAULT NULL,
  reserved4 varchar2(50) DEFAULT NULL,
  reserved5 varchar2(50) DEFAULT NULL,
  reserved6 varchar2(50) DEFAULT NULL,
  reserved7 varchar2(50) DEFAULT NULL,
  reserved8 varchar2(50) DEFAULT NULL,
  reserved9 varchar2(50) DEFAULT NULL,
  reserved10 varchar2(50) DEFAULT NULL
);


插入一条记录:

Insert into "t_ctimetrigger" (ID,TRIGGERNAME,JOBDETAILNAME,CRONEXPRESSION,TARGETOBJECT,METHODNAME,CONCURRENT,STATE,ISSPRINGBEAN,README,RESERVED1,RESERVED2,RESERVED3,RESERVED4,RESERVED5,RESERVED6,RESERVED7,RESERVED8,RESERVED9,RESERVED10) values (2,'triggername','detailname','0/5 * * * * ?','com.chinalife.business.quartz.ctime.ISCSynAllData','run','0         ','1         ','0         ','说明',null,null,null,null,null,null,null,null,null,null);


创建实体对象：

package com.chinalife.business.quartz.ctime;


import java.io.Serializable;


public class CTimeTrigger implements Serializable {
private static final long serialVersionUID = 5286939244925336768L;
private Long id;  
    // 设置trigger名称  
    private String triggername;    
    //设置表达式  
    private String cronexpression;  
    // 设置Job名称  
    private String jobdetailname;  
    //任务类名  
    private String targetobject;  
    //类名对应的方法名  
    private String methodname;  
    //设置是否并发启动任务 0是false 非0是true  
    private String concurrent;  
    // 如果计划任务不存则为1 存在则为0  
    private String state;  
    private String readme;  
    //是否是已经存在的springBean 1是  0 否  
    private String isspringbean;  
    /** 预留字段1 */  
    private String reserved1;  
    /** 预留字段2 */  
    private String reserved2;  
    /** 预留字段3 */  
    private String reserved3;  
    /** 预留字段4 */  
    private String reserved4;  
    /** 预留字段5 */  
    private String reserved5;  
    /** 预留字段6 */  
    private String reserved6;  
    /** 预留字段7 */  
    private String reserved7;  
    /** 预留字段8 */  
    private String reserved8;  
    /** 预留字段9 */  
    private String reserved9;  
    /** 预留字段10 */  
    private String reserved10;
    
    public CTimeTrigger(){}
    
    /** full constructor */  
    public CTimeTrigger(String triggername, String cronexpression,  
            String jobdetailname, String targetobject, String methodname,  
            String concurrent, String state, String readme,String isspringbean) {  
        this.triggername = triggername;  
        this.cronexpression = cronexpression;  
        this.jobdetailname = jobdetailname;  
        this.targetobject = targetobject;  
        this.methodname = methodname;  
        this.concurrent = concurrent;  
        this.state = state;  
        this.readme = readme;  
        this.isspringbean=isspringbean;  
    }  
    
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getTriggername() {
return triggername;
}
public void setTriggername(String triggername) {
this.triggername = triggername;
}
public String getCronexpression() {
return cronexpression;
}
public void setCronexpression(String cronexpression) {
this.cronexpression = cronexpression;
}
public String getJobdetailname() {
return jobdetailname;
}
public void setJobdetailname(String jobdetailname) {
this.jobdetailname = jobdetailname;
}
public String getTargetobject() {
return targetobject;
}
public void setTargetobject(String targetobject) {
this.targetobject = targetobject;
}
public String getMethodname() {
return methodname;
}
public void setMethodname(String methodname) {
this.methodname = methodname;
}
public String getConcurrent() {
return concurrent;
}
public void setConcurrent(String concurrent) {
this.concurrent = concurrent;
}
public String getState() {
return state;
}
public void setState(String state) {
this.state = state;
}
public String getReadme() {
return readme;
}
public void setReadme(String readme) {
this.readme = readme;
}
public String getIsspringbean() {
return isspringbean;
}
public void setIsspringbean(String isspringbean) {
this.isspringbean = isspringbean;
}
public String getReserved1() {
return reserved1;
}
public void setReserved1(String reserved1) {
this.reserved1 = reserved1;
}
public String getReserved2() {
return reserved2;
}
public void setReserved2(String reserved2) {
this.reserved2 = reserved2;
}
public String getReserved3() {
return reserved3;
}
public void setReserved3(String reserved3) {
this.reserved3 = reserved3;
}
public String getReserved4() {
return reserved4;
}
public void setReserved4(String reserved4) {
this.reserved4 = reserved4;
}
public String getReserved5() {
return reserved5;
}
public void setReserved5(String reserved5) {
this.reserved5 = reserved5;
}
public String getReserved6() {
return reserved6;
}
public void setReserved6(String reserved6) {
this.reserved6 = reserved6;
}
public String getReserved7() {
return reserved7;
}
public void setReserved7(String reserved7) {
this.reserved7 = reserved7;
}
public String getReserved8() {
return reserved8;
}
public void setReserved8(String reserved8) {
this.reserved8 = reserved8;
}
public String getReserved9() {
return reserved9;
}
public void setReserved9(String reserved9) {
this.reserved9 = reserved9;
}
public String getReserved10() {
return reserved10;
}
public void setReserved10(String reserved10) {
this.reserved10 = reserved10;
}
}


创建定时器管理类：

package com.chinalife.business.quartz.ctime;


import java.util.ArrayList;
import java.util.Date;
import java.util.List;


import org.apache.log4j.Logger;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.BeanFactoryAware;
import org.springframework.scheduling.quartz.CronTriggerBean;
import org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean;


public class QuartzManager implements BeanFactoryAware {
private Logger log = Logger.getLogger(QuartzManager.class);  
    private Scheduler scheduler;  
    private static BeanFactory beanFactory = null;
    
    public void reScheduleJob(){
    // 通过查询数据库里计划任务来配置计划任务
    //System.out.println("reScheduleJob---->"+new Date());
//List<CTimeTrigger> quartzList = new ArrayList<CTimeTrigger>();//这里是手动设置了一个
/*CTimeTrigger tbcq=new CTimeTrigger();
tbcq.setTriggername("triggername");
tbcq.setCronexpression("0/5 * * * * ?");
tbcq.setJobdetailname("detailname");
tbcq.setTargetobject("com.chinalife.business.quartz.ctime.ISCSynAllData");
tbcq.setMethodname("run");
tbcq.setConcurrent("1");
tbcq.setState("1");
tbcq.setReadme("readme");
tbcq.setIsspringbean("0");
quartzList.add(tbcq);*/
/*
try{

                     //读取数据库
ICTimeTriggerDao dao = (ICTimeTriggerDao) this.beanFactory.getBean("ctimeTriggerDao");
quartzList = dao.getAllTrigger();
if (quartzList != null && quartzList.size() > 0) {
for (CTimeTrigger tbcq1 : quartzList) {
configQuatrz(tbcq1);
}
}
}catch(Exception e){
e.printStackTrace();
}*/
    }
    
    public boolean configQuatrz(CTimeTrigger tbcq) {  
        boolean result = false;  
        try {  
            // 运行时可通过动态注入的scheduler得到trigger  
            CronTriggerBean trigger = (CronTriggerBean) scheduler.getTrigger(  
                    tbcq.getTriggername(), Scheduler.DEFAULT_GROUP);  
            // 如果计划任务已存在则调用修改方法  
            if (trigger != null) {  
                change(tbcq, trigger);  
            } else {  
                // 如果计划任务不存在并且数据库里的任务状态为可用时,则创建计划任务  
                if (tbcq.getState().equals("1")) {  
                    this.createCronTriggerBean(tbcq);  
                }  
            }  
            result = true;  
        } catch (Exception e) {  
            result = false;  
            e.printStackTrace();  
        }  
      
        return result;  
    }      
    
    public void change(CTimeTrigger tbcq, CronTriggerBean trigger)  
            throws Exception {  
        // 如果任务为可用  
        if (tbcq.getState().equals("1")) {  
            // 判断从DB中取得的任务时间和现在的quartz线程中的任务时间是否相等  
            // 如果相等，则表示用户并没有重新设定数据库中的任务时间，这种情况不需要重新rescheduleJob  
            if (!trigger.getCronExpression().equalsIgnoreCase(  
                    tbcq.getCronexpression())) {  
                trigger.setCronExpression(tbcq.getCronexpression());  
                scheduler.rescheduleJob(tbcq.getTriggername(),  
                        Scheduler.DEFAULT_GROUP, trigger);  
                log.info(new Date() + ": 更新" + tbcq.getTriggername() + "计划任务");  
            }  
        } else {  
            // 不可用  
            scheduler.pauseTrigger(trigger.getName(), trigger.getGroup());// 停止触发器  
            scheduler.unscheduleJob(trigger.getName(), trigger.getGroup());// 移除触发器  
            scheduler.deleteJob(trigger.getJobName(), trigger.getJobGroup());// 删除任务  
            log.info(new Date() + ": 删除" + tbcq.getTriggername() + "计划任务");  
      
        }  
      
    }
    /** 
     * 创建/添加计划任务 
     *  
     * @param tbcq 
     *            计划任务配置对象 
     * @throws Exception 
     */  
    public void createCronTriggerBean(CTimeTrigger tbcq) throws Exception {  
        // 新建一个基于Spring的管理Job类  
        MethodInvokingJobDetailFactoryBean mjdfb = new MethodInvokingJobDetailFactoryBean();  
        mjdfb.setName(tbcq.getJobdetailname());// 设置Job名称  
        // 如果定义的任务类为Spring的定义的Bean则调用 getBean方法  
        if (tbcq.getIsspringbean().equals("1")) {  
            mjdfb.setTargetObject(beanFactory.getBean(tbcq.getTargetobject()));// 设置任务类  
        } else {  
            // 否则直接new对象  
            mjdfb.setTargetObject(Class.forName(tbcq.getTargetobject()).newInstance());// 设置任务类  
        }  
      
        mjdfb.setTargetMethod(tbcq.getMethodname());// 设置任务方法  
        mjdfb.setConcurrent(tbcq.getConcurrent().equals("0") ? false : true); // 设置是否并发启动任务  
        mjdfb.afterPropertiesSet();// 将管理Job类提交到计划管理类  
        // 将Spring的管理Job类转为Quartz管理Job类  
        JobDetail jobDetail = new JobDetail();  
        jobDetail = (JobDetail) mjdfb.getObject();  
        jobDetail.setName(tbcq.getJobdetailname());  
        scheduler.addJob(jobDetail, true); // 将Job添加到管理类  
        // 新一个基于Spring的时间类  
        CronTriggerBean c = new CronTriggerBean();  
        c.setCronExpression(tbcq.getCronexpression());// 设置时间表达式  
        c.setName(tbcq.getTriggername());// 设置名称  
        c.setJobDetail(jobDetail);// 注入Job  
        c.setJobName(tbcq.getJobdetailname());// 设置Job名称  
        scheduler.scheduleJob(c);// 注入到管理类  
        scheduler.rescheduleJob(tbcq.getTriggername(), Scheduler.DEFAULT_GROUP,c);// 刷新管理类  
        log.info(new Date() + ": 新建" + tbcq.getTriggername() + "计划任务");  
    }  
    
@Override
public void setBeanFactory(BeanFactory factory) throws BeansException {
this.beanFactory = factory;  
}

public Scheduler getScheduler() {  
   return scheduler;  
}  
 
public void setScheduler(Scheduler scheduler) {  
   this.scheduler = scheduler;  
}    
public BeanFactory getBeanFactory() {  
   return beanFactory;  
}  
}


需要调用的类：

package com.chinalife.business.quartz.ctime;


import java.util.Date;


public class ISCSynAllData {

public void run(){  
        System.out.println("=========自定义bean开始执行任务"+new Date());  
   
    } 
}


配置文件：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:p="http://www.springframework.org/schema/p"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:jee="http://www.springframework.org/schema/jee"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-2.5.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">

<bean id="ctimeTriggerDao" class="com.chinalife.business.quartz.ctime.CTimeTriggerDaoImp"></bean>

<bean id="quartzManagerBean" class="com.chinalife.business.quartz.ctime.QuartzManager">
<property name="scheduler" ref="schedulerManager" />
</bean>
<bean id="quartzManagerJobDetail"
class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
<property name="targetObject" ref="quartzManagerBean" />
<property name="targetMethod" value="reScheduleJob" />
<property name="concurrent" value="false" />
</bean>
<!-- 主定时计划 -->
<bean id="quartzManagerTrigger"
class="org.springframework.scheduling.quartz.SimpleTriggerBean">
<property name="jobDetail" ref="quartzManagerJobDetail" />
<!-- 延时1秒 执行任务 -->
<property name="startDelay" value="1000" />
<!-- 任务执行周期 6秒 -->
<property name="repeatInterval" value="20000" />
</bean>
<!-- 总管理类 如果将lazy-init='false'那么容器启动就会执行调度程序  -->
<bean id="schedulerManager" lazy-init="false" autowire="no"
class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
<property name="triggers">
<list>
<ref bean="quartzManagerTrigger" />
</list>
</property>
</bean>
</beans>

紫青蓝
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringBoot集成Quartz数据库配置定时任务
人生就像一场戏
09-28 3905
Spring Boot 整合 Quartz 实现定时任务集群 文章参考 https://blog.csdn.net/l18848956739/article/details/86597709 https://blog.csdn.net/xibei19921101/article/details/105012749 https://blog.csdn.net/WLPJLP/article/details/103908448 https://blog.csdn.net/sqlgao22/arti.
Spring整合Quartz实现动态定时器
2401_83412087的博客
03-31 984
** 方式二 ：先删除，然后在创建一个新的Job *//** 方式二：先删除，然后在创建一个新的Job */
Quartz定时器的使用心得-利用java反射动态调用
qq_35926326的博客
09-25 670
第一次写博客，可能不太熟练，望大家体谅，直接上货。我是个小菜鸟，希望能够一起学习，扣扣2541854436。 最近学习quartz的使用，采取动态添加定时任务，利用反射来执行具体的任务内容。 项目地址：https://gitee.com/Bdd_ddB/quartz 项目采取了spring boot + maven构建项目。 主要使用 Scheduler:用于添加定时任...
quartz定时器的使用，定时任务的动态增删改
淋雨一直走啊
10-20 1628
目录 一、简介： 二、使用： 1.添加maven依赖包： 2.编写任务bean，主要封装了定时任务相关的信息 3.编写quartz工具类，实现了一个任务的新增，修改执行时间，暂停，恢复等等 4.编写自定义的Job，这里面写要定时执行的任务（我这里利用反射去执行ScheduleJob中封装的方法） 5.扩展工具类 三、测试： 一、简介： Java的定时任务通常使用以下方式： 使...
定时任务quartz原理以及配置
洛雪
08-06 9811
前些日子有业务需要定时任务，经过了解选择了quartz quartz是一个用java实现的开源调度任务框架，有这么几个好处 1.配置方便，支持多任务 2.业务-定时可控，灵活配置，随时更改 3.支持分布式集群 下面是核心元素的关系 在quartz中，Scheduler调度线程主要有两个：regular Scheduler Thread（执行常规调度）和Misfire Schedul...
Quartz定时器的动态配置
杨小矞的博客园
03-18 4413
代码解释：Quartz定时器的动态配置。 1、需要的库环境，maven配置如下 <!-- TIMER --> <dependency> <groupId>org.quartz-scheduler</groupId> <artifactId>quartz</artifactId> <...
java 动态添加定时器_Spring整合Quartz实现动态定时器的示例代码
weixin_30341571的博客
02-16 163
一、版本说明spring3.1以下的版本必须使用quartz1.x系列，3.1以上的版本才支持quartz 2.x，不然会出错。原因：spring对于quartz的支持实现，org.springframework.scheduling.quartz.CronTriggerBean继承了org.quartz.CronTrigger，在quartz1.x系列中org.quartz.CronTrigge...
spring+quartz动态设置定时时间
03-24
- 使用数据库存储：Quartz支持将Job和Trigger的信息存储在数据库中，通过更新数据库中的Trigger信息，可以实现动态调整定时时间。这种方法更适用于分布式环境，因为所有节点都可以访问同一份配置。 3. **代码表...
spring+springMVC+mybatis+quartz动态定时任务创建
09-18
例如，可以使用Spring的ApplicationContext来初始化Quartz的Scheduler，然后在运行时通过Spring的Bean工厂动态创建和管理Job。Quartz的JobDetail和Trigger可以被配置为动态加载，这样就能根据业务逻辑或外部输入来...
Spring整合Quartz实现动态定时器的示例代码
08-31
在Java开发中，Spring框架与Quartz库的整合可以让我们轻松地实现动态定时任务。Quartz是一个开源的作业调度框架，允许程序按照预定的时间执行任务。而Spring则提供了与Quartz的集成，使得我们可以利用Spring的IoC...
spring+quartz实现动态设置定时任务
10-28
在Spring中，我们可以通过实现`org.springframework.scheduling.quartz.JobDetailBean`和`org.springframework.scheduling.quartz.CronTriggerBean`，将它们作为Spring Bean进行管理。 3. **动态调度**：通过Spring...
spring+InitializingBean+quartz+定时器-附件资源
03-05
spring+InitializingBean+quartz+定时器-附件资源
SpringBoot使用Quartz实现定时任务动态配置
qq_42666609的博客
09-28 1403
SpringBoot使用quartz实现定时任务动态配置，实现在后台增删改查数据库中配置的定时任务，
Spring—Quartz定时调度CronTrigger时间配置格式说明与实例
jiweji88的博客
08-12 153
CronTrigger配置格式: 格式: [秒] [分] [小时] [日] [月] [周] [年] 通配符说明: * ：表示所有值. 例如:在分的字段上设置 "*",表示每一分钟都会触发。 ?  ：表示不指定值。使用的场景为不需要关心当前设置这个字段的值。例如:要在每月的10号触发一个操作，但不关心是周几，所以需要周位置的那个字段设置为"?" 具体设置为 0 0 0
Springboot 使用Quartz定时器执行多个定时任务 配置篇
2401_84046577的博客
04-04 1155
在这个部分总结了2019年到目前为止Java常见面试问题，取其面试核心编写成这份文档笔记，从中分析面试官的心理，摸清面试官的“套路”，可以说搞定90%以上的Java中高级面试没一点难度。本节总结的内容涵盖了：消息队列、Redis缓存、分库分表、读写分离、设计高并发系统、分布式系统、高可用系统、SpringCloud微服务架构等一系列互联网主流高级技术的知识点。（上述只是一个整体目录大纲，每个点里面都有如下所示的详细内容，从面试问题——分析面试官心理——剖析面试题——完美解答的一个过程）
quartz定时器时间设置规则
qbm123456789的博客
07-05 3603
定时器
如何配置quartz定时器?
weixin_44465729的博客
04-26 223
首先创建配置文件:applicationContext_job.xml <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-insta...
定时器quartz时间设置
aoeace
12-07 346
  转：https://www.cnblogs.com/skyblue/p/3296350.html http://www.quartz-scheduler.org/api/previous_versions/2.0.2/org/quartz/CronTrigger.html   The public interface for inspecting settings specific...
SpringBoot依赖之Spring Data Redis一有序集合Sorted Set
最新发布
ahauedu的专栏
08-19 1019
​ 通过上述步骤，我们成功在 Spring Boot 项目中使用 Spring Data Redis 实现了对 Redis 有序集合（Sorted Set）类型的操作。您可以使用这些方法来处理排行榜、定时任务和延时队列的数据结构需求。​ 这是基本的有序集合Sorted Set相关操作，还是要结合具体的业务选择具体的存储类型，这样对于项目后期的迭代具有事半功倍的效果。所以项目前期的技术选型也很重要，不容忽视。可以关注我一起学习，一起为程序员职业生涯蓄能。
spring+springmvc+mybatis+quartz动态定时任务创建
07-26
在Spring中，我们可以通过配置文件来创建和管理Quartz定时任务，也可以使用注解来指定任务的触发条件和执行逻辑。 在实际应用中，我们可以使用Spring MVC来处理HTTP请求，并调用MyBatis来访问数据库。同时，通过...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值