SpringBoot+Quartz图形化(有源码)

最新推荐文章于 2025-04-16 16:45:55 发布
置顶 最新推荐文章于 2025-04-16 16:45:55 发布
阅读量2.1k 收藏 7
点赞数 3
文章标签： SpringBoot Quartz Mybatis “Vue
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/hu15081398237/article/details/93467302
版权

在我们日常的开发中，很多时候，定时任务都不是写死的，都是写好代码，页面配置，定时器执行规则都是灵活的，是写到数据库中，从而实现定时任务的动态配置，下面就通过一个简单的示例，来实现这个功能。

https://github.com/huyufan1995/Quartz.git

本次demo是SpringBoot的，毕竟是19年了，废话不多说了。

1.maven引入的依赖

<dependencies>
    <dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
        <version>1.3.0</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-quartz</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <scope>runtime</scope>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>

    <dependency>
        <groupId>com.github.pagehelper</groupId>
        <artifactId>pagehelper</artifactId>
        <version>5.0.0</version>
    </dependency>

</dependencies>

2.application.yml配置文件

spring:
  datasource:
    url: jdbc:mysql://127.0.0.1:3306/quartz_test?useSSL=false&useUnicode=true
    username: root
    password: 123456
    driver-class-name: com.mysql.jdbc.Driver

# Mybatis����
mybatis:
  mapperLocations: classpath:mapper/*.xml
  configLocation: classpath:mybatis.xml

3.整合quartz官方推荐要写一个配置文件quartz.properties

# 固定前缀org.quartz
# 主要分为scheduler、threadPool、jobStore、plugin等部分
#
#
org.quartz.scheduler.instanceName = DefaultQuartzScheduler
org.quartz.scheduler.rmi.export = false
org.quartz.scheduler.rmi.proxy = false
org.quartz.scheduler.wrapJobExecutionInUserTransaction = false

# 实例化ThreadPool时，使用的线程类为SimpleThreadPool
org.quartz.threadPool.class = org.quartz.simpl.SimpleThreadPool

# threadCount和threadPriority将以setter的形式注入ThreadPool实例
# 并发个数
org.quartz.threadPool.threadCount = 5
# 优先级
org.quartz.threadPool.threadPriority = 5
org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread = true

org.quartz.jobStore.misfireThreshold = 5000

# 默认存储在内存中
#org.quartz.jobStore.class = org.quartz.simpl.RAMJobStore

#持久化
org.quartz.jobStore.class = org.quartz.impl.jdbcjobstore.JobStoreTX

org.quartz.jobStore.tablePrefix = QRTZ_

org.quartz.jobStore.dataSource = qzDS

org.quartz.dataSource.qzDS.driver = com.mysql.jdbc.Driver

org.quartz.dataSource.qzDS.URL = jdbc:mysql://127.0.0.1:3306/quartz_test?useSSL=false&useUnicode=true&characterEncoding=UTF-8

org.quartz.dataSource.qzDS.user = root

org.quartz.dataSource.qzDS.password = 123456

org.quartz.dataSource.qzDS.maxConnections = 10

4.mysql需要的quartz官方表支持

DROP TABLE IF EXISTS QRTZ_FIRED_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_PAUSED_TRIGGER_GRPS;
DROP TABLE IF EXISTS QRTZ_SCHEDULER_STATE;
DROP TABLE IF EXISTS QRTZ_LOCKS;
DROP TABLE IF EXISTS QRTZ_SIMPLE_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_SIMPROP_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_CRON_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_BLOB_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_JOB_DETAILS;
DROP TABLE IF EXISTS QRTZ_CALENDARS;


CREATE TABLE QRTZ_JOB_DETAILS
  (
    SCHED_NAME VARCHAR(120) NOT NULL,
    JOB_NAME  VARCHAR(200) NOT NULL,
    JOB_GROUP VARCHAR(200) NOT NULL,
    DESCRIPTION VARCHAR(250) 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 NULL,
    PRIMARY KEY (SCHED_NAME,JOB_NAME,JOB_GROUP)
);

CREATE TABLE QRTZ_TRIGGERS
  (
    SCHED_NAME VARCHAR(120) NOT NULL,
    TRIGGER_NAME VARCHAR(200) NOT NULL,
    TRIGGER_GROUP VARCHAR(200) NOT NULL,
    JOB_NAME  VARCHAR(200) NOT NULL,
    JOB_GROUP VARCHAR(200) NOT NULL,
    DESCRIPTION VARCHAR(250) NULL,
    NEXT_FIRE_TIME BIGINT(13) NULL,
    PREV_FIRE_TIME BIGINT(13) NULL,
    PRIORITY INTEGER NULL,
    TRIGGER_STATE VARCHAR(16) NOT NULL,
    TRIGGER_TYPE VARCHAR(8) NOT NULL,
    START_TIME BIGINT(13) NOT NULL,
    END_TIME BIGINT(13) NULL,
    CALENDAR_NAME VARCHAR(200) NULL,
    MISFIRE_INSTR SMALLINT(2) NULL,
    JOB_DATA BLOB NULL,
    PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
    FOREIGN KEY (SCHED_NAME,JOB_NAME,JOB_GROUP)
        REFERENCES QRTZ_JOB_DETAILS(SCHED_NAME,JOB_NAME,JOB_GROUP)
);

CREATE TABLE QRTZ_SIMPLE_TRIGGERS
  (
    SCHED_NAME VARCHAR(120) NOT NULL,
    TRIGGER_NAME VARCHAR(200) NOT NULL,
    TRIGGER_GROUP VARCHAR(200) 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),
    FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
        REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
);

CREATE TABLE QRTZ_CRON_TRIGGERS
  (
    SCHED_NAME VARCHAR(120) NOT NULL,
    TRIGGER_NAME VARCHAR(200) NOT NULL,
    TRIGGER_GROUP VARCHAR(200) NOT NULL,
    CRON_EXPRESSION VARCHAR(200) NOT NULL,
    TIME_ZONE_ID VARCHAR(80),
    PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
    FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
        REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
);

CREATE TABLE QRTZ_SIMPROP_TRIGGERS
  (          
    SCHED_NAME VARCHAR(120) NOT NULL,
    TRIGGER_NAME VARCHAR(200) NOT NULL,
    TRIGGER_GROUP VARCHAR(200) NOT NULL,
    STR_PROP_1 VARCHAR(512) NULL,
    STR_PROP_2 VARCHAR(512) NULL,
    STR_PROP_3 VARCHAR(512) NULL,
    INT_PROP_1 INT NULL,
    INT_PROP_2 INT NULL,
    LONG_PROP_1 BIGINT NULL,
    LONG_PROP_2 BIGINT NULL,
    DEC_PROP_1 NUMERIC(13,4) NULL,
    DEC_PROP_2 NUMERIC(13,4) NULL,
    BOOL_PROP_1 VARCHAR(1) NULL,
    BOOL_PROP_2 VARCHAR(1) NULL,
    PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
    FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP) 
    REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
);

CREATE TABLE QRTZ_BLOB_TRIGGERS
  (
    SCHED_NAME VARCHAR(120) NOT NULL,
    TRIGGER_NAME VARCHAR(200) NOT NULL,
    TRIGGER_GROUP VARCHAR(200) NOT NULL,
    BLOB_DATA BLOB NULL,
    PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
    FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
        REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
);

CREATE TABLE QRTZ_CALENDARS
  (
    SCHED_NAME VARCHAR(120) NOT NULL,
    CALENDAR_NAME  VARCHAR(200) NOT NULL,
    CALENDAR BLOB NOT NULL,
    PRIMARY KEY (SCHED_NAME,CALENDAR_NAME)
);

CREATE TABLE QRTZ_PAUSED_TRIGGER_GRPS
  (
    SCHED_NAME VARCHAR(120) NOT NULL,
    TRIGGER_GROUP  VARCHAR(200) NOT NULL, 
    PRIMARY KEY (SCHED_NAME,TRIGGER_GROUP)
);

CREATE TABLE QRTZ_FIRED_TRIGGERS
  (
    SCHED_NAME VARCHAR(120) NOT NULL,
    ENTRY_ID VARCHAR(95) NOT NULL,
    TRIGGER_NAME VARCHAR(200) NOT NULL,
    TRIGGER_GROUP VARCHAR(200) NOT NULL,
    INSTANCE_NAME VARCHAR(200) NOT NULL,
    FIRED_TIME BIGINT(13) NOT NULL,
    SCHED_TIME BIGINT(13) NOT NULL,
    PRIORITY INTEGER NOT NULL,
    STATE VARCHAR(16) NOT NULL,
    JOB_NAME VARCHAR(200) NULL,
    JOB_GROUP VARCHAR(200) NULL,
    IS_NONCONCURRENT VARCHAR(1) NULL,
    REQUESTS_RECOVERY VARCHAR(1) NULL,
    PRIMARY KEY (SCHED_NAME,ENTRY_ID)
);

CREATE TABLE QRTZ_SCHEDULER_STATE
  (
    SCHED_NAME VARCHAR(120) NOT NULL,
    INSTANCE_NAME VARCHAR(200) NOT NULL,
    LAST_CHECKIN_TIME BIGINT(13) NOT NULL,
    CHECKIN_INTERVAL BIGINT(13) NOT NULL,
    PRIMARY KEY (SCHED_NAME,INSTANCE_NAME)
);

CREATE TABLE QRTZ_LOCKS
  (
    SCHED_NAME VARCHAR(120) NOT NULL,
    LOCK_NAME  VARCHAR(40) NOT NULL, 
    PRIMARY KEY (SCHED_NAME,LOCK_NAME)
);
 

5.可以写一个接口，方便扩展

6.实体类Entity

7.因为springboot都是写配置类，我们不写尽量不写配置文件，所以如下

package com.example.quartz.config;

import org.quartz.Scheduler;
import org.quartz.ee.servlet.QuartzInitializerListener;
import org.springframework.beans.factory.config.PropertiesFactoryBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.ClassPathResource;

import java.io.IOException;
import java.util.Properties;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;


@Configuration
public class SchedulerConfig {

    @Bean(name="SchedulerFactory")
    public SchedulerFactoryBean schedulerFactoryBean() throws IOException {
        SchedulerFactoryBean factory = new SchedulerFactoryBean();
        factory.setQuartzProperties(quartzProperties());
        return factory;
    }

    @Bean
    public Properties quartzProperties() throws IOException {
        PropertiesFactoryBean propertiesFactoryBean = new PropertiesFactoryBean();
        propertiesFactoryBean.setLocation(new ClassPathResource("/quartz.properties"));
        //在quartz.properties中的属性被读取并注入后再初始化对象
        propertiesFactoryBean.afterPropertiesSet();
        return propertiesFactoryBean.getObject();
    }

    /*
     * quartz初始化监听器
     */
    @Bean
    public QuartzInitializerListener executorListener() {
        return new QuartzInitializerListener();
    }

    /*
     * 通过SchedulerFactoryBean获取Scheduler的实例
     */
    @Bean(name="Scheduler")
    public Scheduler scheduler() throws IOException {
        return schedulerFactoryBean().getScheduler();
    }
}

8.主要Controller代码如下

package com.example.quartz.controller;


import java.util.HashMap;
import java.util.Map;

import com.example.quartz.entity.BaseJob;
import com.example.quartz.entity.JobAndTrigger;
import com.example.quartz.service.IJobAndTriggerService;
import com.github.pagehelper.PageInfo;
import org.quartz.CronScheduleBuilder;
import org.quartz.CronTrigger;
import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.JobKey;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.TriggerBuilder;
import org.quartz.TriggerKey;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;



@RestController
@RequestMapping(value="/job")
public class JobController
{
    @Autowired
    private IJobAndTriggerService iJobAndTriggerService;

    //加入Qulifier注解，通过名称注入bean
    @Autowired @Qualifier("Scheduler")
    private Scheduler scheduler;

    private static Logger log = LoggerFactory.getLogger(JobController.class);


    @PostMapping(value="/addjob")
    public void addjob(@RequestParam(value="jobClassName")String jobClassName,
                       @RequestParam(value="jobGroupName")String jobGroupName,
                       @RequestParam(value="cronExpression")String cronExpression) throws Exception
    {
        addJob(jobClassName, jobGroupName, cronExpression);
    }

    public void addJob(String jobClassName, String jobGroupName, String cronExpression)throws Exception{

        // 启动调度器
        scheduler.start();

        //构建job信息
        JobDetail jobDetail = JobBuilder.newJob(getClass(jobClassName).getClass()).withIdentity(jobClassName, jobGroupName).build();

        //表达式调度构建器(即任务执行的时间)
        CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(cronExpression);

        //按新的cronExpression表达式构建一个新的trigger
        CronTrigger trigger = TriggerBuilder.newTrigger().withIdentity(jobClassName, jobGroupName)
                .withSchedule(scheduleBuilder).build();

        try {
            scheduler.scheduleJob(jobDetail, trigger);

        } catch (SchedulerException e) {
            System.out.println("创建定时任务失败"+e);
            throw new Exception("创建定时任务失败");
        }
    }

    /**
     * 暂停
     * @param jobClassName
     * @param jobGroupName
     * @throws Exception
     */
    @PostMapping(value="/pausejob")
    public void pausejob(@RequestParam(value="jobClassName")String jobClassName, @RequestParam(value="jobGroupName")String jobGroupName) throws Exception
    {
        jobPause(jobClassName, jobGroupName);
    }

    public void jobPause(String jobClassName, String jobGroupName) throws Exception
    {
        scheduler.pauseJob(JobKey.jobKey(jobClassName, jobGroupName));
    }

    /**
     * 恢复
     * @param jobClassName
     * @param jobGroupName
     * @throws Exception
     */
    @PostMapping(value="/resumejob")
    public void resumejob(@RequestParam(value="jobClassName")String jobClassName, @RequestParam(value="jobGroupName")String jobGroupName) throws Exception
    {
        jobresume(jobClassName, jobGroupName);
    }

    public void jobresume(String jobClassName, String jobGroupName) throws Exception
    {
        scheduler.resumeJob(JobKey.jobKey(jobClassName, jobGroupName));
    }

    /**
     * 重启
     * @param jobClassName
     * @param jobGroupName
     * @param cronExpression
     * @throws Exception
     */
    @PostMapping(value="/reschedulejob")
    public void rescheduleJob(@RequestParam(value="jobClassName")String jobClassName,
                              @RequestParam(value="jobGroupName")String jobGroupName,
                              @RequestParam(value="cronExpression")String cronExpression) throws Exception
    {
        jobreschedule(jobClassName, jobGroupName, cronExpression);
    }

    public void jobreschedule(String jobClassName, String jobGroupName, String cronExpression) throws Exception
    {
        try {
            TriggerKey triggerKey = TriggerKey.triggerKey(jobClassName, jobGroupName);
            // 表达式调度构建器
            CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(cronExpression);

            CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);

            // 按新的cronExpression表达式重新构建trigger
            trigger = trigger.getTriggerBuilder().withIdentity(triggerKey).withSchedule(scheduleBuilder).build();

            // 按新的trigger重新设置job执行
            scheduler.rescheduleJob(triggerKey, trigger);
        } catch (SchedulerException e) {
            System.out.println("更新定时任务失败"+e);
            throw new Exception("更新定时任务失败");
        }
    }

    /**
     * 删除
     * @param jobClassName
     * @param jobGroupName
     * @throws Exception
     */
    @PostMapping(value="/deletejob")
    public void deletejob(@RequestParam(value="jobClassName")String jobClassName, @RequestParam(value="jobGroupName")String jobGroupName) throws Exception
    {
        jobdelete(jobClassName, jobGroupName);
    }

    public void jobdelete(String jobClassName, String jobGroupName) throws Exception
    {
        scheduler.pauseTrigger(TriggerKey.triggerKey(jobClassName, jobGroupName));
        scheduler.unscheduleJob(TriggerKey.triggerKey(jobClassName, jobGroupName));
        scheduler.deleteJob(JobKey.jobKey(jobClassName, jobGroupName));
    }


    @GetMapping(value="/queryjob")
    public Map<String, Object> queryjob(@RequestParam(value="pageNum")Integer pageNum, @RequestParam(value="pageSize")Integer pageSize)
    {
        PageInfo jobAndTrigger = iJobAndTriggerService.getJobAndTriggerDetails(pageNum, pageSize);
        Map<String, Object> map = new HashMap<String, Object>();
        map.put("JobAndTrigger", jobAndTrigger);
        map.put("number", jobAndTrigger.getTotal());
        return map;
    }

    public static BaseJob getClass(String classname) throws Exception
    {
        Class<?> class1 = Class.forName(classname);
        return (BaseJob)class1.newInstance();
    }


}

 

9.service实现类

 

10.最重要的Mapper文件

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >  
<mapper namespace="com.example.quartz.dao.JobAndTriggerMapper">

   <resultMap id="BaseResultMap" type="com.example.quartz.entity.JobAndTrigger">
      <result column="JOB_NAME" property="JOB_NAME"/>
      <result column="JOB_GROUP" property="JOB_GROUP"/>
      <result column="JOB_CLASS_NAME" property="JOB_CLASS_NAME"/>
      <result column="TRIGGER_NAME" property="TRIGGER_NAME"/>
      <result column="TRIGGER_GROUP" property="TRIGGER_GROUP"/>
      <result column="REPEAT_INTERVAL" property="REPEAT_INTERVAL"/>
      <result column="TIMES_TRIGGERED" property="TIMES_TRIGGERED"/>
      <result column="CRON_EXPRESSION" property="CRON_EXPRESSION"/>
      <result column="TIME_ZONE_ID" property="TIME_ZONE_ID"/>


   </resultMap>

    <select id="getJobAndTriggerDetails" resultMap="BaseResultMap">
         SELECT
            qrtz_job_details.JOB_NAME,
            qrtz_job_details.JOB_GROUP,
            qrtz_job_details.JOB_CLASS_NAME,
            qrtz_triggers.TRIGGER_NAME,
            qrtz_triggers.TRIGGER_GROUP,
            qrtz_cron_triggers.CRON_EXPRESSION,
            qrtz_cron_triggers.TIME_ZONE_ID
         FROM
            qrtz_job_details
         JOIN qrtz_triggers
         JOIN qrtz_cron_triggers ON qrtz_job_details.JOB_NAME = qrtz_triggers.JOB_NAME
         AND qrtz_triggers.TRIGGER_NAME = qrtz_cron_triggers.TRIGGER_NAME
         AND qrtz_triggers.TRIGGER_GROUP = qrtz_cron_triggers.TRIGGER_GROUP
         AND qrtz_job_details.JOb_GROUP = qrtz_cron_triggers.TRIGGER_GROUP
    </select>
    
</mapper>

 

效果

 

问题整理：官方提供的表中，有个暂停的记录表，但是我使用暂停过程中，确实能够暂停，但是表中无记录信息，如果正式开发中，肯定需要页面开始与暂停切换，状态的一些信息，最好是将定时器的一部分信息在存放自己生成的表中，方便业务扩展

猿之村
关注
SpringBoot集成Quartz实现持久化存储和可视化页面管理
萌新求带
11-07 3322
前言 本文主要是Springboot集成Quartz实现定时任务的数据库存储以及前端页面的可视化管理，所使用的主要工具有：Springboot、Mybatis-Plus、Quartz、Layui、Mysql等 正文 1.准备环境 1.创建数据库 因为本例子中业务数据和定时数据是分开的，所以先创建两个空数据库，一个用于业务，一个用于Quartz，数据库名字任意，我的是：bml_base（业务）、bml_quartz（定时） 2.创建项目 创建一个Springboot项目，勾选一些必需依赖，例如druid、qu
Springboot实现定时器quartz应用举例。
weixin_42603009的博客
06-29 1224
上一篇中我们说明了Springboot实现定时器quartz中文文档说明， 在开写主要内容前，我们来说明其他方式。 两者都是针对较简单的情况下。其一是，SpringBoot自带定时注解。其二是，定时线程池。 关于利用这两者前面已经实现、介绍过了，也给出（所有的只是为了更好的理解定时器）。 另外再讲一个自带的Timer来帮助理解（这三个都是三个基于线程来实现的）。 package com.cun; ...
springboot+quartz 动态化配置定时任务
07-25
springboot+quartz 动态化配置，可在页面操作，查看、添加、修改、删除，暂停等操作
SpringBoot整合Quartz调度框架实现任务调度（附学习源码）
Java笔记虾
03-18 1593
来源：gyoomi.blog.youkuaiyun.com/article/details/83382000一、引言定时任务调度是Java开发中不可或缺的重要部分，但是Java自带的Time等任务调度...
Spring Boot 自定义定时任务组件深度解析：Quartz 集成与设计模式实战
最新发布
〆、挽风的博客
04-16 1111
*** 异步任务 Configuration*/@AutoConfiguration// 1️⃣ Spring Boot自动配置注解，标识这是一个自动配置类@EnableAsync// 2️⃣ 启用Spring的异步方法执行功能@Bean// 3️⃣ 声明该方法返回的对象会被注册为Spring Beanreturn new BeanPostProcessor() { // 4️⃣ 创建BeanPostProcessor实现（Bean生命周期处理器）@Overrideif (!
SpringBoot 整合quartz 并图形化显示
xu812063047的博客
08-25 1655
spring boot 整合quartz 并持久化到数据库，前端UI也可以操作定时任务
Spring Boot Admin-UI 图形化界面显示Actuator信息
李思净的博客
10-10 1155
AdminUI 启动AdminUI界面，需要单独定义AdminUI-Server服务，独立于功能服务之外。所有功能服务作为AdminUI-Client服务连接到Server服务，Server服务检测到连接后对进行监控处理。 Client pom <dependency> <groupId>de.codecentric</groupId> <artifa...
springboot-Quartz 集成源码分析和demo
guo_xl的专栏
12-18 2298
springboot-Quartz 集成源码跟踪 在pom.xml里加入 &amp;amp;amp;amp;amp;amp;lt;dependency&amp;amp;amp;amp;amp;amp;gt; &amp;amp;amp;amp;amp;amp;lt;groupId&amp;amp;amp;amp;amp;amp;gt;org.springframework.boot&amp;amp;amp;amp;amp;amp;lt;/groupId&
SpringBoot+Vue报表调度平台管理系统源码分享
而报表调度则涉及到定时任务的创建、管理和执行，常见的任务调度工具有Quartz、Spring Task等。在这个项目中，涉及到报表的设计、生成和调度，可以支持定时任务的执行，实现报表的定时更新和发送。 ### 知识点五：...
springboot整合kettle项目源码
12-15
标题 "springboot整合kettle项目源码" 描述了一个基于Spring Boot框架的集成Kettle（Pentaho Data Integration，简称KDI）的工程实例。Kettle是一款强大的ETL（提取、转换、加载）工具，它允许开发者通过编写Java...
RabbitMq整合Springboot超全实战案例+图文演示+源码自取_rabbitmq springboot 实战
2401_84166672的博客
04-15 693
RabbitMQ是一种开源的消息队列软件，它实现了高级消息队列协议（AMQP），提供了可靠的消息传递机制以及支持分布式应用程序之间的通信。RabbitMQ支持多种编程语言，如Java、Python、Ruby、PHP等等，并且可以在不同的操作系统上运行，如Windows、Linux、Mac OS等。RabbitMQ的核心理念是分离应用程序之间的通信，允许开发人员将其应用程序解耦，从而使它们更加容易理解、扩展和维护。
Quartz定时任务图形界面的系统
05-14
定时任务图形界面的系统，集成框架有：SpringMVC、MyBaits、Thymeleaf、Bootstrap3、Quartz、log4j2；
java8源码-springboo-quartz:动态界面管理定时任务
06-04
java8 源码 项目结构 ├── demoeee │   ├── com //启动整个项目的moudle │   └── example │   └── demo │ ├──aop //个人定义的写的自定义注解 │ ├──api //swagger API 访问地址：http://localhost:8080/quartz/swagger-ui.html │ ├──command //命令开发模式 │ ├──commonfactory//普通工厂开发模式 │ ├──decorate //装饰者开发模式 │ ├──observer //观察者开发模式 │ ├──lambda //java8的一个新特性 │ ├──config //定时任务的配置 │ ├──controller //任务控制层 │ ├──dao //对应mybatis xml的配置文件 │ ├──entity //实体类 │ ├──interceptor //实体类 │ ├──service //业务逻辑层 │ ├──util //帮助类 │ ├──需要执行的job //实体类 │   └──DemoApplicatio
spring-boot-starter-quartz：Quartz-Scheduler的Spring-Boot自动配置
01-31
Quartz Scheduler的Spring-Boot自动配置 只是Quartz Scheduler的Spring-Boot启动器。 当然，Quartz Scheduler已经有好几个启动器，但是它们都不能满足我的所有需求，因此我创建了自己的启动器。 这只是一个业余项目。 使用此工具（尤其是在生产系统中）的风险自负。 内容 需求，依赖 弹簧靴 石英调度器 经过Spring Boot测试 （直到1.0.2）1.3.8、1.4.6、1.5.3、1.5.6， （自1.0.3起）1.4.6、1.5.10、1.5.16、1.5.17 用法 < dependency> < groupId>de.chandre.quartz</ groupId> < artifactId>spring-boot-starter-quartz</ artifactId> < version>1.0.5</ version> </ dependency> 也许您必须显式启用软件包的组件扫描： @SpringBootApplication @EnableAutoConfiguratio
springboot整合quartz的demo
01-30
springboot整合quartz的demo，实现了simpleTrigger和cronTrigger，具体功能如下：项目启动后，每隔两秒输出一串星号，每隔三秒输出一串#号，访问controller后，添加定时任务，十秒后输出访问者的ip
spring-boot-starter
ityqing的博客
08-29 333
starter 是 Spring Boot 的一个重要组成部分，用于限制您需要执行的手动配置依赖项数量。要想有效地使用 Spring Boot，您应该了解 starter。
SpringBoot多任务Quartz动态管理Scheduler，时间配置，页面+源码
凡尘炼心的博客
04-14 8491
页面展现后台任务处理：恢复任务 15s执行一次后台打印消息不BB了，直接上代码import... /** * 调度工厂类 * Created by jinyu on 2018/4/14/014. */ @Service @Component public class MySchedulerFactory { private static Logger logger = Logger...
Spring Boot集成持久化Quartz定时任务管理和界面展示
weixin_34236869的博客
04-04 323
本文是对之前的一篇文章Spring+SpringMVC+mybatis+Quartz整合代码部分做的一个修改和补充， 其中最大的变化就是后台框架变成了Spring Boot。 本工程所用到的技术或工具有： Spring Boot Mybatis Quartz PageHelper VueJS ElementUI MySql数据库 正文 配置 本例中仍然是使用mysql...
SpringBoot+Quartz+Maven+MySql实现动态定时任务
bduwps8393的博客
08-01 276
　　1.Quartz需要导入的包，Maven配置　　org.quartz-scheduler　　quartz　　2.2.3　　org.quartz-scheduler　　quartz-jobs　　2.2.3　　2.Quartz需要用到的表　　DROP TABLE IF EXISTS qrtz_fired_triggers;　　DROP TABLE IF EXISTS qrtz...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值