quartz之动态定时器实现

water_java water_java 博客等级 墨衍会员 · AI 创作全网分发 墨衍智能分发 本文由作者通过墨衍一键同步至各平台 1分发平台 600+累计阅读 605平均单平台 已同步平台 优快云 微信公众号 微博 知乎 掘金 百家号 博客园 抖音 小红书 你的文章也可以这样分发 墨衍会员 ¥399起/年，写一次发全网 我也要 码龄7年
关注
原创 最新推荐文章于 2026-07-27 10:13:35 发布 605 阅读 AI 写同款· GEO 优化 ›
Quartz与Spring集成——创建调度器 在《Quartz与Spring集成—— SchedulerFactoryBean的初始化分析》一文中介绍过，Spring集成Quartz时的初始化过程。创建调度器也是初始化过程中的一步，本文将着重介绍Quartz初始化时是如何创建调度器的。 阅读详情

quartz之动态定时器实现

quartz调度框架的内置表

可以参考我博文：https://blog.youkuaiyun.com/water_java/article/details/103826256查看内置表的关系

进入quartz的官网http://www.quartz-scheduler.org/，点击Downloads，下载后在目录\docs\dbTables下有常用数据库创建quartz表的脚本，例如：“tables_mysql.sql”

   table_mysql.sql
   table_mysql_innodb.sql
   上述两者所有的数据库引擎不一样

Spring整合Quartz

在这里插入图片描述

换源

pom依赖：
本来连接池是默认用c3p0，但我需要的是druid，所以需要换

   <dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz-jobs</artifactId>
            <version>2.2.1</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.10</version>
        </dependency>

我们还需要逆行生成代码，所以需要添加相关依赖


<!--别忘了降低mysql的版本-->
    <mysql.version>5.1.44</mysql.version>
    
   <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
            <version>${mysql.version}</version>
        </dependency>

   <!--逆向生成插件-->
        <resources>
        <!--解决mybatis-generator-maven-plugin运行时没有将XxxMapper.xml文件放入target文件夹的问题-->
        <resource>
            <directory>src/main/java</directory>
            <includes>
                <include>**/*.xml</include>
            </includes>
        </resource>
        <!--解决mybatis-generator-maven-plugin运行时没有将jdbc.properites文件放入target文件夹的问题-->
        <resource>
            <directory>src/main/resources</directory>
            <includes>
                <include>*.properties</include>
                <include>*.xml</include>
                <include>*.yml</include>
            </includes>
        </resource>
        </resources>


  <plugin>
                <groupId>org.mybatis.generator</groupId>
                <artifactId>mybatis-generator-maven-plugin</artifactId>
                <version>1.3.2</version>
                <dependencies>
                    <!--使用Mybatis-generator插件不能使用太高版本的mysql驱动 -->
                    <dependency>
                        <groupId>mysql</groupId>
                        <artifactId>mysql-connector-java</artifactId>
                        <version>${mysql.version}</version>
                    </dependency>
                </dependencies>
                <configuration>
                    <overwrite>true</overwrite>
                </configuration>
            </plugin>

在项目中添加quartz.properties文件(这样就不会加载自带的properties文件)
此文件的内容主要分为：scheduler，ThreadPool，JobStore，plugin，Datasources等部分，
覆盖properties文件的目的是覆盖默认的数据源，更换为druid的数据配置

quartz.properties

#
#============================================================================
# Configure Main Scheduler Properties 调度器属性
#============================================================================
org.quartz.scheduler.instanceName: DefaultQuartzScheduler
org.quartz.scheduler.instanceId = AUTO
org.quartz.scheduler.rmi.export: false
org.quartz.scheduler.rmi.proxy: false
org.quartz.scheduler.wrapJobExecutionInUserTransaction: false
org.quartz.threadPool.class: org.quartz.simpl.SimpleThreadPool
org.quartz.threadPool.threadCount= 10
org.quartz.threadPool.threadPriority: 5
org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread: true
org.quartz.jobStore.misfireThreshold: 60000
#============================================================================
# Configure JobStore
#============================================================================
#存储方式使用JobStoreTX，也就是数据库
org.quartz.jobStore.class: org.quartz.impl.jdbcjobstore.JobStoreTX
org.quartz.jobStore.driverDelegateClass:org.quartz.impl.jdbcjobstore.StdJDBCDelegate
#使用自己的配置文件
org.quartz.jobStore.useProperties:true
#数据库中quartz表的表名前缀
org.quartz.jobStore.tablePrefix:qrtz_
org.quartz.jobStore.dataSource:qzDS
#是否使用集群（如果项目只部署到 一台服务器，就不用了）
org.quartz.jobStore.isClustered = true
#============================================================================
# Configure Datasources
#============================================================================
#配置数据库源（org.quartz.dataSource.qzDS.maxConnections: c3p0配置的是有s的，druid数据源没有s）
org.quartz.dataSource.qzDS.connectionProvider.class:com.hsl.quartz02.util.DruidConnectionProvider
org.quartz.dataSource.qzDS.driver: com.mysql.jdbc.Driver
org.quartz.dataSource.qzDS.URL: jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf8
org.quartz.dataSource.qzDS.user: root
org.quartz.dataSource.qzDS.password: 1234
#csp0的为org.quartz.dataSource.qzDS.maxConnections: 10,druid的没有s
org.quartz.dataSource.qzDS.maxConnection: 10

Druid连接池的Quartz扩展类：DruidConnectionProvider

package com.hsl.quartz02.util;

import com.alibaba.druid.pool.DruidDataSource;
import org.quartz.SchedulerException;
import org.quartz.utils.ConnectionProvider;

import java.sql.Connection;
import java.sql.SQLException;


/**
 * [Druid连接池的Quartz扩展类]
 */
public class DruidConnectionProvider implements ConnectionProvider {

     /*
     * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     *
     * 常量配置，与quartz.properties文件的key保持一致(去掉前缀)，同时提供set方法，Quartz框架自动注入值。
     *
     * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     */

    //JDBC驱动
    public String driver;
    //JDBC连接串
    public String URL;
    //数据库用户名
    public String user;
    //数据库用户密码
    public String password;
    //数据库最大连接数
    public int maxConnection;
    //数据库SQL查询每次连接返回执行到连接池，以确保它仍然是有效的。
    public String validationQuery;

    private boolean validateOnCheckout;

    private int idleConnectionValidationSeconds;

    public String maxCachedStatementsPerConnection;

    private String discardIdleConnectionsSeconds;

    public static final int DEFAULT_DB_MAX_CONNECTIONS = 10;

    public static final int DEFAULT_DB_MAX_CACHED_STATEMENTS_PER_CONNECTION = 120;

    //Druid连接池
    private DruidDataSource datasource;

    /*
    * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    *
    * 接口实现
    *
    * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    */
    public Connection getConnection() throws SQLException {
        return datasource.getConnection();
    }

    public void shutdown() throws SQLException {
        datasource.close();
    }
    public void initialize() throws SQLException{
        if (this.URL == null) {
            throw new SQLException("DBPool could not be created: DB URL cannot be null");
        }

        if (this.driver == null) {
            throw new SQLException("DBPool driver could not be created: DB driver class name cannot be null!");
        }

        if (this.maxConnection < 0) {
            throw new SQLException("DBPool maxConnectins could not be created: Max connections must be greater than zero!");
        }

        datasource = new DruidDataSource();
        try{
            datasource.setDriverClassName(this.driver);
        } catch (Exception e) {
            try {
                throw new SchedulerException("Problem setting driver class name on datasource: " + e.getMessage(), e);
            } catch (SchedulerException e1) {
            }
        }

        datasource.setUrl(this.URL);
        datasource.setUsername(this.user);
        datasource.setPassword(this.password);
        datasource.setMaxActive(this.maxConnection);
        datasource.setMinIdle(1);
        datasource.setMaxWait(0);
        datasource.setMaxPoolPreparedStatementPerConnectionSize(this.DEFAULT_DB_MAX_CACHED_STATEMENTS_PER_CONNECTION);

        if (this.validationQuery != null) {
            datasource.setValidationQuery(this.validationQuery);
            if(!this.validateOnCheckout)
                datasource.setTestOnReturn(true);
            else
                datasource.setTestOnBorrow(true);
            datasource.setValidationQueryTimeout(this.idleConnectionValidationSeconds);
        }
    }

    /*
    * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    *
    * 提供get set方法
    *
    * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    */
    public String getDriver() {
        return driver;
    }

    public void setDriver(String driver) {
        this.driver = driver;
    }

    public String getURL() {
        return URL;
    }

    public void setURL(String URL) {
        this.URL = URL;
    }

    public String getUser() {
        return user;
    }

    public void setUser(String user) {
        this.user = user;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public int getMaxConnection() {
        return maxConnection;
    }

    public void setMaxConnection(int maxConnection) {
        this.maxConnection = maxConnection;
    }

    public String getValidationQuery() {
        return validationQuery;
    }

    public void setValidationQuery(String validationQuery) {
        this.validationQuery = validationQuery;
    }

    public boolean isValidateOnCheckout() {
        return validateOnCheckout;
    }

    public void setValidateOnCheckout(boolean validateOnCheckout) {
        this.validateOnCheckout = validateOnCheckout;
    }

    public int getIdleConnectionValidationSeconds() {
        return idleConnectionValidationSeconds;
    }

    public void setIdleConnectionValidationSeconds(int idleConnectionValidationSeconds) {
        this.idleConnectionValidationSeconds = idleConnectionValidationSeconds;
    }

    public DruidDataSource getDatasource() {
        return datasource;
    }

    public void setDatasource(DruidDataSource datasource) {
        this.datasource = datasource;
    }
}

自定义MyJobFactory，解决spring不能在quartz中注入bean的问题

MyJobFactory

package com.hsl.quartz02.quartz;

import lombok.extern.slf4j.Slf4j;
import org.quartz.spi.TriggerFiredBundle;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
import org.springframework.scheduling.quartz.AdaptableJobFactory;
import org.springframework.stereotype.Component;

@Component
@Slf4j
public class MyJobFactory extends AdaptableJobFactory {

    //这个由Spring自动注入
    @Autowired
    private AutowireCapableBeanFactory autowireCapableBeanFactory;

    //重写Job任务对象的创建实例方法
    @Override
    protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception {
        Object jobInstance = super.createJobInstance(bundle);
        //通过以下方式，解决Job任务无法使用Spring中的Bean问题
        autowireCapableBeanFactory.autowireBean(jobInstance);
        return jobInstance;
    }
}

quartz调度框架与spring框架整合的配置类

QuartzConfiguration（quartz调度框架与spring框架整合的配置类，主要是要将org.quartz.Scheduler交给spring进行管理）

package com.hsl.quartz02.quartz;

import org.quartz.Scheduler;
import org.springframework.beans.factory.annotation.Autowired;
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 org.springframework.scheduling.quartz.SchedulerFactoryBean;

import java.io.IOException;
import java.util.Properties;

@Configuration
public class QuartzConfiguration {

    @Autowired
    private MyJobFactory myJobFactory;

    //创建调度器工厂
    @Bean
        public SchedulerFactoryBean schedulerFactoryBean(){
            //1.创建SchedulerFactoryBean
            //2.加载自定义的quartz.properties配置文件
            //3.设置MyJobFactory

            SchedulerFactoryBean factoryBean=new SchedulerFactoryBean();
            try {
                factoryBean.setQuartzProperties(quartzProperties());
                factoryBean.setJobFactory(myJobFactory);
                return factoryBean;
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
    }

    @Bean
    public Properties quartzProperties() throws IOException {
        PropertiesFactoryBean propertiesFactoryBean=new PropertiesFactoryBean();
        propertiesFactoryBean.setLocation(new ClassPathResource("/quartz.properties"));
        propertiesFactoryBean.afterPropertiesSet();
        return propertiesFactoryBean.getObject();
    }

    @Bean(name="scheduler")
    public Scheduler scheduler(){
        return schedulerFactoryBean().getScheduler();
    }
}

application.yml

server:
  port: 80
  servlet:
    context-path: /

spring:
  datasource:
    #1.JDBC
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf8
    username: root
    password: 1234
    druid:
      #2.连接池配置
      #初始化连接池的连接数量 大小，最小，最大
      initial-size: 5
      min-idle: 5
      max-active: 20
      #配置获取连接等待超时的时间
      max-wait: 60000
      #配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
      time-between-eviction-runs-millis: 60000
      # 配置一个连接在池中最小生存的时间，单位是毫秒
      min-evictable-idle-time-millis: 30000
      validation-query: SELECT 1 FROM DUAL
      test-while-idle: true
      test-on-borrow: true
      test-on-return: false
      # 是否缓存preparedStatement，也就是PSCache  官方建议MySQL下建议关闭   个人建议如果想用SQL防火墙 建议打开
      pool-prepared-statements: true
      max-pool-prepared-statement-per-connection-size: 20
      # 配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙
      filter:
        stat:
          merge-sql: true
          slow-sql-millis: 5000
      #3.基础监控配置
      web-stat-filter:
        enabled: true
        url-pattern: /*
        #设置不统计哪些URL
        exclusions: "*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*"
        session-stat-enable: true
        session-stat-max-count: 100
      stat-view-servlet:
        enabled: true
        url-pattern: /druid/*
        reset-enable: true
        #设置监控页面的登录名和密码
        login-username: admin
        login-password: admin
        allow: 127.0.0.1
        #deny: 192.168.1.100

#显示日志
logging:
  level:
    com.hsl.quartz02.mapper: debug

Quartz02Application

package com.hsl.quartz02;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.transaction.annotation.EnableTransactionManagement;

@MapperScan("com.hsl.quartz02.mapper")
@EnableTransactionManagement
@EnableScheduling
@SpringBootApplication
public class Quartz02Application {

    public static void main(String[] args) {
        SpringApplication.run(Quartz02Application.class, args);
    }

}

读取数据库中表达式启动定时任务1（每5s执行
MyJob

package com.hsl.quartz02.quartz;

import lombok.extern.slf4j.Slf4j;
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.stereotype.Component;

import java.util.Date;

@Component
@Slf4j
public class MyJob implements Job {

    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
//       每五秒执行一次
        System.out.println("MyJob是一个空的任务计划,时间："+new Date().toLocaleString());
    }
}

在这里插入图片描述
ScheduleTriggerMapper.java

/**
     * 查询触发器中包含的所有任务
     * @return
     */
    List<ScheduleTrigger> queryScheduleTriggerLst();

ScheduleTriggerParamMapper.java


/**
     * 查询出当前任务类对应所需的参数
     * @param triggerId
     * @return
     */
    List<ScheduleTriggerParam> queryScheduleParamLst(Integer triggerId);

ScheduleTriggerMapper.xml

<select id="queryScheduleTriggerLst" resultType="com.javaxl.quartz02.model.ScheduleTrigger">
    select <include refid="Base_Column_List"/>
    from t_schedule_trigger
  </select>

ScheduleTriggerParamMapper.xml

 <select id="queryScheduleParamLst" resultType="com.javaxl.quartz02.model.ScheduleTriggerParam">
    select <include refid="Base_Column_List"/>
    from t_schedule_trigger_param where schedule_trigger_id=#{triggerId}
  </select>

ScheduleTriggerParamServiceImpl.java


@Service
public class ScheduleTriggerParamServiceImpl implements ScheduleTriggerParamService {

    @Autowired
    private ScheduleTriggerParamMapper scheduleTriggerParamMapper;

    @Override
    public List<ScheduleTriggerParam> queryScheduleParamLst(Integer triggerId) {
        return scheduleTriggerParamMapper.queryScheduleParamLst(triggerId);
    }
}

ScheduleTriggerParamService


public interface ScheduleTriggerParamService {
    public List<ScheduleTriggerParam> queryScheduleParamLst(Integer triggerId);
}

ScheduleTriggerServiceImpl

package com.hsl.quartz02.service.impl;

import com.hsl.quartz02.mapper.ScheduleTriggerMapper;
import com.hsl.quartz02.mapper.ScheduleTriggerParamMapper;
import com.hsl.quartz02.model.ScheduleTrigger;
import com.hsl.quartz02.model.ScheduleTriggerParam;
import org.quartz.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * @author water
 * @site www.water.com
 * @company xxx公司
 * @create 2020-01-04 11:57
 */
@Service
public class ScheduleTriggerServiceImpl {
    @Autowired
    private ScheduleTriggerMapper scheduleTriggerMapper;

    @Autowired
    private ScheduleTriggerParamMapper scheduleTriggerParamMapper;

    @Autowired
    private Scheduler scheduler;

    @Scheduled(cron = "0/10 * * * * ?")
    public void refreshScheduler() {
        try {
            List<ScheduleTrigger> scheduleTriggers = scheduleTriggerMapper.queryScheduleTriggerLst();
            if (null != scheduleTriggers) {
                for (ScheduleTrigger scheduleTrigger : scheduleTriggers) {
                    String cron = scheduleTrigger.getCron();//表达式
                    String jobName = scheduleTrigger.getJob_name();//任务名称
                    String jobGroup = scheduleTrigger.getJob_group();//任务分组
                    String status = scheduleTrigger.getStatus();//任务状态
                    //根据jobName和jobGroup生成TriggerKey
                    TriggerKey triggerKey = TriggerKey.triggerKey(jobName, jobGroup);
                    //根据TriggerKey到Scheduler调度器中获取触发器
                    CronTrigger cronTrigger = (CronTrigger) scheduler.getTrigger(triggerKey);
                    if (null == cronTrigger) {
                        if (status.equals("0"))
                            continue;
//                        只执行一次
                        System.out.println("创建调度器");
                        //创建任务详情
                        JobDetail jobDetail = JobBuilder
                                .newJob((Class<? extends Job>) Class.forName(jobName))
                                .withIdentity(jobName, jobGroup)
                                .build();

                        //往Job 任务中传递参数
                        JobDataMap jobDataMap = jobDetail.getJobDataMap();
                        List<ScheduleTriggerParam> scheduleTriggerParams = scheduleTriggerParamMapper.queryScheduleParamLst(scheduleTrigger.getId());
                        for (ScheduleTriggerParam scheduleTriggerParam : scheduleTriggerParams) {
                            jobDataMap.put(scheduleTriggerParam.getName(), scheduleTriggerParam.getValue());
                        }
//创建表达式调度器
                        CronScheduleBuilder cronSchedule =
                                CronScheduleBuilder.cronSchedule(cron);

                        //创建Trigger
                        cronTrigger = TriggerBuilder.newTrigger()
                                .withIdentity(jobName, jobGroup)
                                .withSchedule(cronSchedule)
                                .build();

                        //将jobDetail和Trigger注入到scheduler调度器中
                        scheduler.scheduleJob(jobDetail, cronTrigger);
                    } else {
                        //System.out.println("Quartz 调度任务中已存在该任务");
                        if (status.equals("0")) {
                            JobKey jobKey = JobKey.jobKey(jobName, jobGroup);
                            scheduler.deleteJob(jobKey);
                            continue;
                        }
                        //调度器中的表达式
                        String cronExpression =
                                cronTrigger.getCronExpression();

                        if (!cron.equals(cronExpression)) {
                            //创建表达式调度器
                            CronScheduleBuilder cronSchedule = CronScheduleBuilder.cronSchedule(cron);

                            //重构
                            cronTrigger = cronTrigger.getTriggerBuilder()
                                    .withIdentity(triggerKey)
                                    .withSchedule(cronSchedule)
                                    .build();

                            //刷新调度器
                            scheduler.rescheduleJob(triggerKey, cronTrigger);
                        }
                    }
                }
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

在这里插入图片描述
在这里插入图片描述
更改定时任务状态（启用/禁用），定时任务1停止

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
读取数据库中表达式启动定时任务2（每5s执行），在对应作业类中打印定时任务2携带的参数
MyJob1

package com.hsl.quartz02.quartz;

import com.hsl.quartz02.service.ScheduleTriggerParamService;
import lombok.extern.slf4j.Slf4j;
import org.quartz.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.Date;

@Component
@Slf4j
public class MyJob1 implements Job {

    @Autowired
    private ScheduleTriggerParamService scheduleTriggerParamService;

    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        JobDetail jobDetail =
                jobExecutionContext.getJobDetail();
        JobDataMap jobDataMap = jobDetail.getJobDataMap();
        System.out.println(new Date().toLocaleString()+"-->携带参数个数:"+jobDataMap.size());
    }
}

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

在这里插入图片描述
读取数据库中表达式启动定时任务3（每5s执行改成每20s执行），更改数据库定时任务表达式，定时任务3对应执行策略相应发生改变。
MyJob2

package com.hsl.quartz02.quartz;

import lombok.extern.slf4j.Slf4j;
import org.quartz.*;
import org.springframework.stereotype.Component;

import java.util.Date;

@Component
@Slf4j
public class MyJob2 implements Job {
    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        JobDetail jobDetail =
                jobExecutionContext.getJobDetail();
        JobDataMap jobDataMap = jobDetail.getJobDataMap();
        System.out.println(new Date().toLocaleString()+"-->MyJob2参数传递name="+jobDataMap.get("name")+",score="+
                jobDataMap.get("score"));
    }
}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

页面版的t_schedule_trigger

具体代码可以点击：https://github.com/water-java/quartz
我在做的过程中出现template模板不存在的错误

在这里插入图片描述
pom加上下面代码
在这里插入图片描述
页面效果：

在这里插入图片描述

在这里插入图片描述

收录于
Quartz

当前文章被收录于：

Quartz
2 篇文章 0 人学习
订阅专栏 查看详情
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
基于Halium 9为小米平板4移植Ubuntu Touch：内核适配与驱动调试实战 在移动设备生态中，Linux内核作为核心，通过硬件抽象层（HAL）管理底层硬件驱动，为上层系统提供统一接口。其模块化设计允许深度定制，是实现跨平台移植的技术基础。Halium项目正是利用这一原理，构建了一个中间层，将安卓内核的硬件支持能力“翻译”成标准Linux发行版能识别的格式，从而在手机、平板等移动设备上运行Ubuntu Touch、postmarketOS等移动Linux系统，极大地拓展了老旧设备的再利用价值。这一技术为开发者提供了在常见安卓硬件上进行Linux系统开发与定制的可能，尤其在嵌入式与物联 阅读详情

相关推荐

3 种 VLA 模型动作表示方案对比：RT-2 离散化 vs π0 流匹配 vs HybridVLA 混合架构

本文深入对比了三种VLA模型动作表示方案：RT-2离散化、π0流匹配和HybridVLA混合架构。分析了各自的技术原理、优势与局限性，并提供了应用场景选择指南，帮助研究者在具身智能领域做出更优的技术选型决策。

weixin_29031161的博客 318

Quartz任务中调用Spring容器中bean及动态调度任务

[size=medium]Quartz 是开源任务调度框架中的翘首，它提供了强大任务调度机制，同时保持了使用的简单性。Quartz 允许开发人员灵活地定义触发器的调度时间表，并可以对触发器和任务进行关联映射。此外，Quartz提供了调度运行环境的持久化机制，可以保存并恢复调度现场，即使系统因故障关闭，任务调度现场数据并不会丢失。此外，Quartz还提供了组件式的侦听器、各种插件、线程池等功能。 ...

John_Kong19的专栏 1232

Datalog语言详解

Datalog是一种声明式逻辑编程语言，起源于数据库理论和逻辑编程领域。作为Prolog的子集，它专注于递归查询和推理，通过定义事实和规则来描述数据关系而非计算步骤。Datalog的关键特性包括规则安全、递归、分层否定和扩展聚合功能，保证了程序的终止性和高效性。相较于SQL，Datalog更擅长处理递归查询；相比Prolog，它更注重数据库友好性。Datalog在程序分析、知识图谱、网络安全等领域有广泛应用，其声明式特性使代码简洁易维护，但同时也面临生态系统小、性能调试难等挑战。现代工具如Soufflé、D

bulita great world 1839

Springboot整合Quartz定时任务框架（Spring解决方案）

spring提供的quartz解决发难

Ricardo.M.Yu的博客 4837

Jetson Nano摄像头选型与配置全攻略：CSI与USB接口实战指南

在嵌入式视觉与边缘计算项目中，摄像头作为核心传感器，其选型与配置直接影响系统性能。CSI（Camera Serial Interface）和USB（Universal Serial Bus）是两种主流接口，前者通过MIPI CSI-2协议直接与SoC通信，具备低延迟、高带宽特性，适合实时性要求高的应用；后者基于通用串行总线标准，即插即用，通用性强。在NVIDIA Jetson Nano平台上，合理选择摄像头接口并优化驱动配置，能充分发挥其GPU加速优势，提升图像处理流水线效率。本文聚焦Jetson Nano

weixin_29190651的博客 323

Fluent求解器——湍流参数的设置

Fluent湍流参数的介绍和设置。

Ronko_G的博客 4万+

SpringBoot-21-异步&定时任务

异步任务&定时任务   异步任务   异步任务知识介绍 在多线程时，后台执行多个任务，我们需要同步等待。此时前台不会给出任何响应，可以采用多线程 的方式解决这个问题。 SpringBoot采用异步注解的方式来解决这个问题，让我们在同步等待的时候，响应前台页面，无需 等待，后台代码执行依旧 实现异步任务        在SpringBoot实现异步任务很简单，在同步等待的任务中添加@Async注解，然后在SpringBoot添加@EnableAsync 代码实现 在com.liang.se

paiidds的博客 3750

【域控制器EMC】域控制器EMC设计总结

汇总项目设计当中关于EMC的设计要点，主要从原理设计、Layout、结构、外设部分总结。满足要求的器件和合理的电路能降低电磁干扰；正确的布局、接地、信号路径、屏蔽等可以减少电磁辐射。结构件设计也会对EMC性能产生影响。

weixin_42098658的博客 1258

Quartz与Spring集成—— SchedulerFactoryBean的初始化分析

Quartz是一个开源的定时调度框架，支持集群部署。我们可以通过其Java API来使用它，或者通过Spring来配置与管理，也可以结合使用两种方式。本文重点分析Quartz与Spring集成时的初始化过程。

beliefer的博客 7万+

布尔可满足性问题（SAT）深度研究

布尔可满足性问题（Boolean Satisfiability Problem, SAT）是计算机科学和数理逻辑中的一个核心决策问题。其定义为：对于一个给定的布尔逻辑公式，判断是否存在一组对其变量的真值赋值（即，为每个变量指定真 (True) 或假 (False)），使得该公式的最终计算结果为真。如果存在这样的赋值，则称该布尔公式是可满足的 (satisfiable)；否则，称其为不可满足的 (unsatisfiable)。

步子哥的博客 493

【图像处理】德里奇（ Deriche）边缘检测器

Deriche边缘检测，同canny算法齐名，因此，知道canny原理，也有必要知道德里奇的检测原理。本篇专门针对德里奇算法展开讨论。

gongdiwudu的专栏 8682

quartz动态定时器实现

今天完成一个定时器的动态实现 在修改数据库表定时器规则 定时器会自动改变 或者说在页面修改状态 定时器是否可用 首先是基础环境配置 quartz调度框架是有内置表的 进入quartz的官网http://www.quartz-scheduler.org/，点击Downloads， 下载后在目录\docs\dbTables下有常用数据库创建quartz表的脚本，例如：“tables_my...

qq_43227109的博客 377

工业产线瑕疵检测：基于 YOLO 的自动化质检系统实战

从工业瑕疵数据集构建到模型训练，从桌面检测界面到产线适用性优化，本文覆盖了一套工业质检系统的完整路线。这个场景的核心评价指标不是最高精度，而是在保证 recall ≥ 0.95 的前提下尽可能压低 false positive——因为漏检的直接成本（客户投诉、质量事故）远高于误报的成本（人工复检）。部署时先设一个偏低的置信度阈值确保覆盖，再通过持续收集人工复检数据来逐步调优。

m0_71589036的博客 63

Spring整合Quartz实现动态定时器

最近在网上查QuartZ的资料 , 很多文章给出的例子都是在application中固定写好计划任务. 这种写死的做法并不实用, 最终看到这篇文章 , 得以实现. 感谢原创作者. 原创链接: http://www.cnblogs.com/xrab/p/5850186.html 　　 一、版本说明 spring3.1以下的版本必须使用quartz1.x系列，3....

diliulian8845的博客 219

TMS_WebGMaps_1.9.8.0_Full_Source

TMS_WebGMaps_1.9.8.0_Full_Source 全源码 delphi cbuilder

ET2012新版免狗免安装绿色软件

ET2012新版免狗免安祖昂绿色软件。，新界面，新视觉，

Spring quartz定时器动态多任务实现

<br />  项目中经常会碰到需要定时执行的任务，并且需要执行什么任务，以及任务执行的时间都由用户自定义的需求。quartz是比较常用的定时器工具，并且在spring框架中也已经做了很好的集成，所以在以spring+hibernate+struts的主流架构中，我们可以采用quartz来做定时器任务的解决方案，下面，我们来看下如何在项目中使用quartz来做动态多任务定时器功能。<br />      1.简单单任务定时器的spring配置<br />view plaincopy to clipboard

争做优秀java技术博客！ 1万+

Devexpress16.2.6破解工具

Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具

java 动态添加定时器_Spring整合Quartz实现动态定时器的示例代码

一、版本说明spring3.1以下的版本必须使用quartz1.x系列，3.1以上的版本才支持quartz 2.x，不然会出错。原因：spring对于quartz的支持实现，org.springframework.scheduling.quartz.CronTriggerBean继承了org.quartz.CronTrigger，在quartz1.x系列中org.quartz.CronTrigge...

weixin_30341571的博客 230

Probability and Statistics - 4th edition

Probability and Statistics - 4th edition

Quartz之动态定时器实现

QuartzSpring整合Quartz 注意：为了讲解内容方便，不涉及到页面，又能将功能展现出来，本篇博客采取的是spring自带的定时器与quartz调度框架一并使用。 Spring整合Quartz 基础环境配置 a、quartz调度框架是有内置表的 进入quartz的官网http://www.quartz-scheduler.org/,点击Downloads, 下载后在目录\docs...

今晚几点睡的博客 786

Spring整合Quartz实现动态定时器的示例代码

转自：https://m.jb51.net/article/103504.htmSpring整合Quartz实现动态定时器的示例代码发布时间：2017-01-19 10:29:05 作者：五指少年本篇文章主要介绍了Spring整合Quartz实现动态定时器的示例代码，具有一定的参考价值，感兴趣的小伙伴们可以参考一下。一、版本说明spring3.1以下的版本必须使用quartz1.x系列，3.1以上...

lch_2016的博客 303
上一篇： Quartz入门
下一篇： Springcloud入门
点赞 0
评论 0
书签 书签 0
water_java
water_java
博客等级 码龄7年 9粉丝 124原创
+ 关注 专栏目录 订阅专栏
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值