Springboot集成quartz定时任务可视化配置​​​​​​​

最新推荐文章于 2024-09-14 18:17:39 发布
最新推荐文章于 2024-09-14 18:17:39 发布
阅读量558 收藏
点赞数
分类专栏： 定时任务 文章标签： quartz
原文链接：https://www.gaoxiaobo.com/web/service/114.html
版权

转自我的个人博客：Springboot集成quartz定时任务可视化配置

 

Quartz

使用quartz定时任务已经有一段时间了，今天记录一下Springboot 2.x集成Quartz。

1、引入quartz jar包

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-quartz</artifactId>
		</dependency>


2、加入quartz配置

spring:
  quartz:
    #相关属性配置
    properties:
      org:
        quartz:
          scheduler:
            instanceName: clusteredScheduler
            instanceId: AUTO
          jobStore:
            class: org.quartz.impl.jdbcjobstore.JobStoreTX
            driverDelegateClass: org.quartz.impl.jdbcjobstore.StdJDBCDelegate
            tablePrefix: QRTZ_
            isClustered: true
            clusterCheckinInterval: 10000
            useProperties: false
          threadPool:
            class: org.quartz.simpl.SimpleThreadPool
            threadCount: 10
            threadPriority: 5
            threadsInheritContextClassLoaderOfInitializingThread: true
    #数据库方式
    job-store-type: jdbc
    #初始化表结构
    #jdbc:
      #initialize-schema: never


我这里的jobstore使用的是jdbc jobstore，所有的定时任务都持久化于数据库中。


3、将存储quartz的表导入数据库

DROP TABLE IF EXISTS `qrtz_blob_triggers`;
CREATE TABLE `qrtz_blob_triggers` (
  `SCHED_NAME` varchar(120) NOT NULL,
  `TRIGGER_NAME` varchar(190) NOT NULL,
  `TRIGGER_GROUP` varchar(190) NOT NULL,
  `BLOB_DATA` blob,
  PRIMARY KEY (`SCHED_NAME`,`TRIGGER_NAME`,`TRIGGER_GROUP`),
  KEY `SCHED_NAME` (`SCHED_NAME`,`TRIGGER_NAME`,`TRIGGER_GROUP`),
  CONSTRAINT `qrtz_blob_triggers_ibfk_1` FOREIGN KEY (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`) REFERENCES `qrtz_triggers` (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

DROP TABLE IF EXISTS `qrtz_calendars`;
CREATE TABLE `qrtz_calendars` (
  `SCHED_NAME` varchar(120) NOT NULL,
  `CALENDAR_NAME` varchar(190) NOT NULL,
  `CALENDAR` blob NOT NULL,
  PRIMARY KEY (`SCHED_NAME`,`CALENDAR_NAME`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

DROP TABLE IF EXISTS `qrtz_cron_triggers`;
CREATE TABLE `qrtz_cron_triggers` (
  `SCHED_NAME` varchar(120) NOT NULL,
  `TRIGGER_NAME` varchar(190) NOT NULL,
  `TRIGGER_GROUP` varchar(190) NOT NULL,
  `CRON_EXPRESSION` varchar(120) NOT NULL,
  `TIME_ZONE_ID` varchar(80) DEFAULT NULL,
  PRIMARY KEY (`SCHED_NAME`,`TRIGGER_NAME`,`TRIGGER_GROUP`),
  CONSTRAINT `qrtz_cron_triggers_ibfk_1` FOREIGN KEY (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`) REFERENCES `qrtz_triggers` (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

DROP TABLE IF EXISTS `qrtz_fired_triggers`;
CREATE TABLE `qrtz_fired_triggers` (
  `SCHED_NAME` varchar(120) NOT NULL,
  `ENTRY_ID` varchar(95) NOT NULL,
  `TRIGGER_NAME` varchar(190) NOT NULL,
  `TRIGGER_GROUP` varchar(190) NOT NULL,
  `INSTANCE_NAME` varchar(190) NOT NULL,
  `FIRED_TIME` bigint(13) NOT NULL,
  `SCHED_TIME` bigint(13) NOT NULL,
  `PRIORITY` int(11) NOT NULL,
  `STATE` varchar(16) NOT NULL,
  `JOB_NAME` varchar(190) DEFAULT NULL,
  `JOB_GROUP` varchar(190) DEFAULT NULL,
  `IS_NONCONCURRENT` varchar(1) DEFAULT NULL,
  `REQUESTS_RECOVERY` varchar(1) DEFAULT NULL,
  PRIMARY KEY (`SCHED_NAME`,`ENTRY_ID`),
  KEY `IDX_QRTZ_FT_TRIG_INST_NAME` (`SCHED_NAME`,`INSTANCE_NAME`),
  KEY `IDX_QRTZ_FT_INST_JOB_REQ_RCVRY` (`SCHED_NAME`,`INSTANCE_NAME`,`REQUESTS_RECOVERY`),
  KEY `IDX_QRTZ_FT_J_G` (`SCHED_NAME`,`JOB_NAME`,`JOB_GROUP`),
  KEY `IDX_QRTZ_FT_JG` (`SCHED_NAME`,`JOB_GROUP`),
  KEY `IDX_QRTZ_FT_T_G` (`SCHED_NAME`,`TRIGGER_NAME`,`TRIGGER_GROUP`),
  KEY `IDX_QRTZ_FT_TG` (`SCHED_NAME`,`TRIGGER_GROUP`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

DROP TABLE IF EXISTS `qrtz_job_details`;
CREATE TABLE `qrtz_job_details` (
  `SCHED_NAME` varchar(120) NOT NULL,
  `JOB_NAME` varchar(190) NOT NULL,
  `JOB_GROUP` varchar(190) NOT NULL,
  `DESCRIPTION` varchar(250) DEFAULT NULL,
  `JOB_CLASS_NAME` varchar(250) NOT NULL,
  `IS_DURABLE` varchar(1) NOT NULL,
  `IS_NONCONCURRENT` varchar(1) NOT NULL,
  `IS_UPDATE_DATA` varchar(1) NOT NULL,
  `REQUESTS_RECOVERY` varchar(1) NOT NULL,
  `JOB_DATA` blob,
  PRIMARY KEY (`SCHED_NAME`,`JOB_NAME`,`JOB_GROUP`),
  KEY `IDX_QRTZ_J_REQ_RECOVERY` (`SCHED_NAME`,`REQUESTS_RECOVERY`),
  KEY `IDX_QRTZ_J_GRP` (`SCHED_NAME`,`JOB_GROUP`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

DROP TABLE IF EXISTS `qrtz_locks`;
CREATE TABLE `qrtz_locks` (
  `SCHED_NAME` varchar(120) NOT NULL,
  `LOCK_NAME` varchar(40) NOT NULL,
  PRIMARY KEY (`SCHED_NAME`,`LOCK_NAME`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

DROP TABLE IF EXISTS `qrtz_paused_trigger_grps`;
CREATE TABLE `qrtz_paused_trigger_grps` (
  `SCHED_NAME` varchar(120) NOT NULL,
  `TRIGGER_GROUP` varchar(190) NOT NULL,
  PRIMARY KEY (`SCHED_NAME`,`TRIGGER_GROUP`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

DROP TABLE IF EXISTS `qrtz_scheduler_state`;
CREATE TABLE `qrtz_scheduler_state` (
  `SCHED_NAME` varchar(120) NOT NULL,
  `INSTANCE_NAME` varchar(190) NOT NULL,
  `LAST_CHECKIN_TIME` bigint(13) NOT NULL,
  `CHECKIN_INTERVAL` bigint(13) NOT NULL,
  PRIMARY KEY (`SCHED_NAME`,`INSTANCE_NAME`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

DROP TABLE IF EXISTS `qrtz_simple_triggers`;
CREATE TABLE `qrtz_simple_triggers` (
  `SCHED_NAME` varchar(120) NOT NULL,
  `TRIGGER_NAME` varchar(190) NOT NULL,
  `TRIGGER_GROUP` varchar(190) NOT NULL,
  `REPEAT_COUNT` bigint(7) NOT NULL,
  `REPEAT_INTERVAL` bigint(12) NOT NULL,
  `TIMES_TRIGGERED` bigint(10) NOT NULL,
  PRIMARY KEY (`SCHED_NAME`,`TRIGGER_NAME`,`TRIGGER_GROUP`),
  CONSTRAINT `qrtz_simple_triggers_ibfk_1` FOREIGN KEY (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`) REFERENCES `qrtz_triggers` (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

DROP TABLE IF EXISTS `qrtz_simprop_triggers`;
CREATE TABLE `qrtz_simprop_triggers` (
  `SCHED_NAME` varchar(120) NOT NULL,
  `TRIGGER_NAME` varchar(190) NOT NULL,
  `TRIGGER_GROUP` varchar(190) NOT NULL,
  `STR_PROP_1` varchar(512) DEFAULT NULL,
  `STR_PROP_2` varchar(512) DEFAULT NULL,
  `STR_PROP_3` varchar(512) DEFAULT NULL,
  `INT_PROP_1` int(11) DEFAULT NULL,
  `INT_PROP_2` int(11) DEFAULT NULL,
  `LONG_PROP_1` bigint(20) DEFAULT NULL,
  `LONG_PROP_2` bigint(20) DEFAULT NULL,
  `DEC_PROP_1` decimal(13,4) DEFAULT NULL,
  `DEC_PROP_2` decimal(13,4) DEFAULT NULL,
  `BOOL_PROP_1` varchar(1) DEFAULT NULL,
  `BOOL_PROP_2` varchar(1) DEFAULT NULL,
  PRIMARY KEY (`SCHED_NAME`,`TRIGGER_NAME`,`TRIGGER_GROUP`),
  CONSTRAINT `qrtz_simprop_triggers_ibfk_1` FOREIGN KEY (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`) REFERENCES `qrtz_triggers` (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

DROP TABLE IF EXISTS `qrtz_triggers`;
CREATE TABLE `qrtz_triggers` (
  `SCHED_NAME` varchar(120) NOT NULL,
  `TRIGGER_NAME` varchar(190) NOT NULL,
  `TRIGGER_GROUP` varchar(190) NOT NULL,
  `JOB_NAME` varchar(190) NOT NULL,
  `JOB_GROUP` varchar(190) NOT NULL,
  `DESCRIPTION` varchar(250) DEFAULT NULL,
  `NEXT_FIRE_TIME` bigint(13) DEFAULT NULL,
  `PREV_FIRE_TIME` bigint(13) DEFAULT NULL,
  `PRIORITY` int(11) DEFAULT NULL,
  `TRIGGER_STATE` varchar(16) NOT NULL,
  `TRIGGER_TYPE` varchar(8) NOT NULL,
  `START_TIME` bigint(13) NOT NULL,
  `END_TIME` bigint(13) DEFAULT NULL,
  `CALENDAR_NAME` varchar(190) DEFAULT NULL,
  `MISFIRE_INSTR` smallint(2) DEFAULT NULL,
  `JOB_DATA` blob,
  PRIMARY KEY (`SCHED_NAME`,`TRIGGER_NAME`,`TRIGGER_GROUP`),
  KEY `IDX_QRTZ_T_J` (`SCHED_NAME`,`JOB_NAME`,`JOB_GROUP`),
  KEY `IDX_QRTZ_T_JG` (`SCHED_NAME`,`JOB_GROUP`),
  KEY `IDX_QRTZ_T_C` (`SCHED_NAME`,`CALENDAR_NAME`),
  KEY `IDX_QRTZ_T_G` (`SCHED_NAME`,`TRIGGER_GROUP`),
  KEY `IDX_QRTZ_T_STATE` (`SCHED_NAME`,`TRIGGER_STATE`),
  KEY `IDX_QRTZ_T_N_STATE` (`SCHED_NAME`,`TRIGGER_NAME`,`TRIGGER_GROUP`,`TRIGGER_STATE`),
  KEY `IDX_QRTZ_T_N_G_STATE` (`SCHED_NAME`,`TRIGGER_GROUP`,`TRIGGER_STATE`),
  KEY `IDX_QRTZ_T_NEXT_FIRE_TIME` (`SCHED_NAME`,`NEXT_FIRE_TIME`),
  KEY `IDX_QRTZ_T_NFT_ST` (`SCHED_NAME`,`TRIGGER_STATE`,`NEXT_FIRE_TIME`),
  KEY `IDX_QRTZ_T_NFT_MISFIRE` (`SCHED_NAME`,`MISFIRE_INSTR`,`NEXT_FIRE_TIME`),
  KEY `IDX_QRTZ_T_NFT_ST_MISFIRE` (`SCHED_NAME`,`MISFIRE_INSTR`,`NEXT_FIRE_TIME`,`TRIGGER_STATE`),
  KEY `IDX_QRTZ_T_NFT_ST_MISFIRE_GRP` (`SCHED_NAME`,`MISFIRE_INSTR`,`NEXT_FIRE_TIME`,`TRIGGER_GROUP`,`TRIGGER_STATE`),
  CONSTRAINT `qrtz_triggers_ibfk_1` FOREIGN KEY (`SCHED_NAME`, `JOB_NAME`, `JOB_GROUP`) REFERENCES `qrtz_job_details` (`SCHED_NAME`, `JOB_NAME`, `JOB_GROUP`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;


ps：上面的表结构是我从数据库导出的，由于外键影响可能建表顺序需要调整。

4、springboot启动类上加上@EnableScheduling注解，就这样springboot已经自动帮我们生成好了任务调度器。

5、封装QuartzJobService

QuartzJobService接口

public interface QuartzJobService {
    /**
     * 创建job
     *
     * @param jobDto          任务类
     */
    void addJob(JobDto jobDto)throws Exception;

    /**
     * 创建job，可传参
     *
     * @param jobDto          任务类
     * @param argMap         map形式参数
     */
    void addJob(JobDto jobDto, Map<String, Object> argMap)throws Exception;

    /**
     * 暂停job
     *
     * @param jobName      任务名称
     * @param jobGroupName 任务所在组名称
     */
    void pauseJob(String jobName, String jobGroupName)throws Exception;

    /**
     * 恢复job
     *
     * @param jobName      任务名称
     * @param jobGroupName 任务所在组名称
     */
    void resumeJob(String jobName, String jobGroupName)throws Exception;


    /**
     * job 更新,只更新频率
     *
     */
    void updateJob(JobDto jobDto)throws Exception;


    /**
     * job 更新,更新频率和参数
     *
     * @param argMap         参数
     */
    void updateJob(JobDto jobDto, Map<String, Object> argMap)throws Exception;

    /**
     * job 更新,只更新更新参数
     *
     * @param jobName      任务名称
     * @param jobGroupName 任务所在组名称
     * @param argMap       参数
     */
    void updateJob(String jobName, String jobGroupName, Map<String, Object> argMap)throws Exception;


    /**
     * job 删除
     *
     * @param jobName      任务名称
     * @param jobGroupName 任务所在组名称
     */
    void deleteJob(String jobName, String jobGroupName)throws Exception;


    /**
     * 启动所有定时任务
     */
    void startAllJobs()throws Exception;

    /**
     * 关闭所有定时任务
     */
    void shutdownAllJobs()throws Exception;

    /**
     * 获取所有任务列表
     *
     * @return
     */
    List<JobDto> getAllJob()throws Exception;


    /**
     * 通过jobname查询job
     * @param jobName
     * @return job的状态
     */
    Trigger.TriggerState getJobByName(String jobName)throws Exception;


}

 

QuartzJobService实现类

@Service
public class QuartzJobServiceImpl implements QuartzJobService {
    private  Logger logger = LoggerFactory.getLogger(getClass());

    @Autowired
    private Scheduler scheduler;

    /**
     * 创建job
     *
     */
    public void addJob(JobDto jobDto)throws Exception {
        addJob(jobDto, null);
    }


    /**
     * 创建job，可传参
     *
     * @param jobDto          任务类

     * @param argMap         map形式参数
     */
    public void addJob(JobDto jobDto, Map<String, Object> argMap)throws Exception {
        Class<?> clazz = jobDto.getClazz();
        String jobName = jobDto.getJobName();
        String groupName = jobDto.getGroupName();
        String cronExpression = jobDto.getCronExpression();
        // 启动调度器
        scheduler.start();
        //构建job信息
        JobDetail jobDetail = JobBuilder.newJob(((Job) clazz.newInstance()).getClass()).withIdentity(jobName, groupName).withDescription(jobDto.getDesc()).build();

        //表达式调度构建器(即任务执行的时间)
        CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(cronExpression);
        //按新的cronExpression表达式构建一个新的trigger
        CronTrigger trigger = TriggerBuilder.newTrigger().withIdentity(jobName, groupName).withSchedule(scheduleBuilder).build();
        //获得JobDataMap，写入数据
        if (argMap != null) {
            trigger.getJobDataMap().putAll(argMap);
        }
        if (!StringUtils.isBlank(jobDto.getTime())){
            trigger.getJobDataMap().put("time", jobDto.getTime());
        }
        scheduler.scheduleJob(jobDetail, trigger);
    }

    /**
     * 暂停job
     *
     * @param jobName      任务名称
     * @param jobGroupName 任务所在组名称
     */
    public void pauseJob(String jobName, String jobGroupName)throws Exception {
        scheduler.pauseJob(JobKey.jobKey(jobName, jobGroupName));
    }

    /**
     * 恢复job
     *
     * @param jobName      任务名称
     * @param jobGroupName 任务所在组名称
     */
    public void resumeJob(String jobName, String jobGroupName)throws Exception {
        scheduler.resumeJob(JobKey.jobKey(jobName, jobGroupName));
    }


    /**
     * job 更新,只更新频率
     *
     */
    public void updateJob(JobDto jobDto)throws Exception {
        updateJob(jobDto, null);
    }


    /**
     * job 更新,更新频率和参数

     * @param argMap         参数
     */
    public void updateJob(JobDto jobDto, Map<String, Object> argMap)throws Exception {
        TriggerKey triggerKey = TriggerKey.triggerKey(jobDto.getJobName(), jobDto.getGroupName());
        // 表达式调度构建器
        CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(jobDto.getCronExpression());
        CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);
        // 按新的cronExpression表达式重新构建trigger
        trigger = trigger.getTriggerBuilder().withIdentity(triggerKey).withSchedule(scheduleBuilder).build();
        //修改map
        if (argMap != null) {
            trigger.getJobDataMap().putAll(argMap);
        }
        trigger.getJobDataMap().put("time", jobDto.getTime());
        // 按新的trigger重新设置job执行
        scheduler.rescheduleJob(triggerKey, trigger);
    }

    /**
     * job 更新,只更新更新参数
     *
     * @param jobName      任务名称
     * @param jobGroupName 任务所在组名称
     * @param argMap       参数
     */
    public void updateJob(String jobName, String jobGroupName, Map<String, Object> argMap)throws Exception {
        TriggerKey triggerKey = TriggerKey.triggerKey(jobName, jobGroupName);
        CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);
        //修改map
        trigger.getJobDataMap().putAll(argMap);
        // 按新的trigger重新设置job执行
        scheduler.rescheduleJob(triggerKey, trigger);

    }


    /**
     * job 删除
     *
     * @param jobName      任务名称
     * @param jobGroupName 任务所在组名称
     */
    public void deleteJob(String jobName, String jobGroupName)throws Exception {
        scheduler.pauseTrigger(TriggerKey.triggerKey(jobName, jobGroupName));
        scheduler.unscheduleJob(TriggerKey.triggerKey(jobName, jobGroupName));
        scheduler.deleteJob(JobKey.jobKey(jobName, jobGroupName));
    }


    /**
     * 启动所有定时任务
     */
    public void startAllJobs()throws Exception {
        scheduler.start();
    }

    /**
     * 关闭所有定时任务
     */
    public void shutdownAllJobs()throws Exception {
        if (!scheduler.isShutdown()) {
            scheduler.shutdown();
        }
    }

    /**
     * 获取所有任务列表
     *
     * @return
     */
    public List<JobDto> getAllJob()throws Exception {
        GroupMatcher<JobKey> matcher = GroupMatcher.anyJobGroup();
        List<JobDto> jobList = new ArrayList<>();
        Set<JobKey> jobKeys = null;
        jobKeys = scheduler.getJobKeys(matcher);
        for (JobKey jobKey : jobKeys) {
            List<? extends Trigger> triggers = scheduler.getTriggersOfJob(jobKey);
            for (Trigger trigger : triggers) {
                JobDto jobDto = new JobDto();

                jobDto.setJobName(jobKey.getName());
                jobDto.setGroupName(jobKey.getGroup());
                JobDetail jobDetail = scheduler.getJobDetail(jobKey);
                jobDto.setClassName(jobDetail.getJobClass().getName());
                jobDto.setClazz(jobDetail.getJobClass());
                jobDto.setTriggerName(trigger.getCalendarName());
                jobDto.setDesc(jobDetail.getDescription());
                jobDto.setTime(trigger.getJobDataMap().getString("time"));

                Trigger.TriggerState triggerState = scheduler.getTriggerState(trigger.getKey());
                jobDto.setStatus(triggerState.name());

                if (trigger instanceof CronTrigger) {
                    CronTrigger cronTrigger = (CronTrigger) trigger;
                    String cronExpression = cronTrigger.getCronExpression();
                    jobDto.setCronExpression(cronExpression);
                }
                jobList.add(jobDto);
            }
        }

        return jobList;
    }


    /**
     * 通过jobname查询job
     * @param jobName
     * @return job的状态
     */
    public Trigger.TriggerState getJobByName(String jobName)throws Exception {
        GroupMatcher<JobKey> matcher = GroupMatcher.anyJobGroup();
        Set<JobKey> jobKeys = null;
        jobKeys = scheduler.getJobKeys(matcher);
        for (JobKey jobKey : jobKeys) {
            List<? extends Trigger> triggers = scheduler.getTriggersOfJob(jobKey);
            for (Trigger trigger : triggers) {
                Trigger.TriggerState triggerState = scheduler.getTriggerState(trigger.getKey());
                if (jobKey.getName().equals(jobName)){
                    return triggerState;
                }
            }
        }
        return null;
    }

}



至此，springboot已经集成好了quartz，通过我们封装的QuartzJobService，很容易就实现可视化的定时任务增删改查操作。

__BoBo
关注
专栏目录
Springboot2+quartz可视化+logback
04-19
在SpringBoot2项目中集成Quartz，首先我们需要在pom.xml文件中添加Quartz和SpringBoot的相关依赖。SpringBoot已经为我们提供了对Quartz的支持，我们可以通过@EnableScheduling注解开启定时任务调度功能。同时，为了...
SpringBoot集成Quartz实现持久化存储和可视化页面管理
萌新求带
11-07 3116
前言 本文主要是Springboot集成Quartz实现定时任务的数据库存储以及前端页面的可视化管理，所使用的主要工具有：Springboot、Mybatis-Plus、Quartz、Layui、Mysql等 正文 1.准备环境 1.创建数据库 因为本例子中业务数据和定时数据是分开的，所以先创建两个空数据库，一个用于业务，一个用于Quartz，数据库名字任意，我的是：bml_base（业务）、bml_quartz（定时） 2.创建项目 创建一个Springboot项目，勾选一些必需依赖，例如druid、qu
java定时器多个组件同时_Quartz 定时器，同时运用多个定时器
weixin_35943077的博客
02-26 396
效果:每天执行两个定时器，两个定时器不相关联。jar版本Quartz 2.2.3Java工程结构图 jar 包下载:链接: https://pan.baidu.com/s/1-7dh620k9PnwAbfKW7Mdiw 提取码: i25tjingPhone.javapublic class jingPhone {private String phoneid;private String bid...
【SpringBoot】调度和执行定时任务--Quartz(超详细)
最新发布
qq_45687669的博客
09-14 1579
}} }Job;import org} }import org} }@Overridetry {// 模拟长时间运行的任务 Thread . sleep(5000);} }try {// 模拟长时间运行的任务 Thread . sleep(5000);} }Job;import orgtry {// 模拟长时间运行的任务 Thread . sleep(5000);
springboot整合quartz
太上码农
11-24 1万+
springboot集成调度框架quartz，各类定时框架比较
springboot整合quartz项目使用（含完整代码）
热门推荐
gorylee的博客
11-28 3万+
学习quartz有两方面，首先xxl-Job，elastic-Job这些框架都是基于quartz的基础上二次开发的，学习quartz更有利于我们加强理解定时调度。第二方面就是工作需求，有一些传统互联网公司还是有很多项目是使用quartz来完成定时任务的开发的。
定时任务之Springboot整合Quartz详解
qq_45087487的博客
08-02 8350
Springboot整合Quartz详解
SpringBoot使用Quartz
weixin_43816557的博客
12-03 5484
所谓"调度"就是制定好的什么时间做什么事情的计划我们使用过的最简单的调度方法就是Timer但是Timer的调度功能过于单一，只能是指定时间的延时调用和周期运行而Quartz可以更详细的指定时间，进行计划调用，是一个当今市面上流行的高效的任务调度管理工具所谓"调度"就是制定好的什么时间做什么事情的计划由OpenSymphony开源组织开发是java编写的,我们使用时需要导入依赖即可
【SpringBoot】廿五、SpringBoot中使用Quartz管理定时任务.pdf
06-30
**二、SpringBoot集成Quartz** 1. **引入Maven依赖** 在SpringBoot项目中，我们需要添加以下两个依赖： - `spring-boot-starter-web`：提供Web支持，因为Quartz可能会通过HTTP接口来管理任务。 - `spring-boot-...
定时任务调度
09-25
日志监控还可以结合ELK（Elasticsearch、Logstash、Kibana）堆栈，实现日志的实时搜索、分析和可视化。 **权限管理**是系统安全的关键部分，确保只有授权的用户或服务能执行特定的操作。在SpringBoot中，可以利用...
SpringBoot的定时调用的加强工具，实现定时任务动态管理-super-scheduled.zip
11-07
总的来说，"super-scheduled"是一个为SpringBoot定制的定时任务管理工具，它扩展了Spring Task的功能，增加了任务的动态管理能力，并计划引入可视化界面，使得定时任务的管理和监控变得更加便捷。对于需要频繁调整或...
springboot项目中Quartz
PaoShan的博客
03-08 3424
从介绍到用例测试，包含依赖等。。。
SpringBoot整合Quartz实现定时任务动态自定义和可视化
m0_61496760的博客
11-06 2612
下面的这个sys_schedule表，里面的字段不要删，但是你可以增加你想要的字段。这是一个抽象类，实现了Job任务类，当前端调用你的controller层方法时，任务触发会先执行这个execute这个方法，这个方法里面会先用这个run方法，关键点就是这个run的抽象方法是我们自己定义的。导入之后把注释去掉，其他的都不用改，需要注意一点tablePrefix这个配置，这个是Quartz需要用到的表的表名前缀，最好不要改，当前你想改也是可以的，但是改起来会很麻烦，要改很多的文件。简单介绍一下表的作用。
springboot使用xxl-job可视化定时任务
Sunny_yaa的博客
04-16 781
springboot实现可视化定时任务
【微服务】springboot整合quartz使用详解
2301_77899321的博客
12-09 3686
Quartz是一个流行的开源的Java定时任务调度框架。它提供了强大的灵活性和可靠性，用于调度和执行各种类型的任务。Quartz可以用于管理和执行定时任务，如定期备份数据、生成报表、发送邮件、调度定时任务等。
springBoot + Quartz
weixin_40461030的博客
05-01 4671
1. Quartz 概述 Quartz 是 OpenSymphony 开源组织在任务调度领域的一个开源项目，完全基于 Java 实现。该项目于 2009 年被 Terracotta 收购，目前是 Terracotta 旗下的一个项目。读者可以到下载Quartz 的发布版本及其源代码。 2. Quartz特点 作为一个优秀的开源调度框架，Quartz 具有以下特点： 强大的调度功能，例如支持丰富多样的调度方法，可以满足各种常规及特殊需求； 灵活的应用方式，例如支持任务和调度的多种组合方式，支持调度数
Springboot 整合 Quartz（定时任务框架）
原名：@程序员大禹
01-31 5502
Quartz是 OpenSymphony 开源组织在 Job scheduling 领域又一个开源项目，完全由 Java 开发，可以用来执行定时任务，类似于 java.util.Timer。持久性作业 - 就是保持调度定时的状态;作业管理 - 对调度作业进行有效的管理;
SpringBoot整合Quartz
qq_34748010的博客
04-01 1986
Quartz是OpenSymphony开源组织在Job scheduling领域又一个开源项目，完全由Java开发，可以用来执行定时任务，类似于java.util.Timer。但是相较于Timer， Quartz增加了很多功能：持久性作业 - 就是保持调度定时的状态;作业管理 - 对调度作业进行有效的管理;
Springboot 整合Quartz
yang_fei9264的博客
07-04 7352
springboot整合quartz相关基本配置
SpringBoot与Quartz集成：可视化管理定时任务
"本文主要讲解如何在SpringBoot项目中使用Quartz进行定时任务的管理和配置，包括Quartz的介绍、依赖引入、数据表创建、Job类编写、配置文件设置、启动与停止任务的方法等关键步骤。" 在SpringBoot中，Quartz是一个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值