springboot整合quartz定时任务( JDBC作业存储方式)

已于 2022-03-12 21:22:24 修改
阅读量2.4k 收藏 1
点赞数 1
文章标签： spring boot spring java
于 2022-03-12 21:11:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42304484/article/details/123449104
版权

springboot整合quartz定时任务( JDBC作业存储方式)

一、介绍

Quartz提供两种基本作业存储类型：RAMJobStore、JDBC作业存储。

  1. RAMJobStore
    RAM也就是内存，默认情况下Quartz会将任务调度存在内存中，这种方式性能是最好的，因为内存的速度是最快的。不好的地方就是数据缺乏持久性，但程序崩溃或者重新发布的时候，所有运行信息都会丢失。
    2、JDBC作业存储
    存到数据库之后，可以做单点也可以做集群，当任务多了之后，可以统一进行管理。关闭或者重启服务器，运行的信息都不会丢失。缺点就是运行速度快慢取决于连接数据库的快慢。

本博客使用jdbc作业存储的方式，同时实现restFul请求对任务启停实现控制，当前应用springboot版本2.4.4。

二、搭建工程

  • pom文件
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>quartz-job</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.4.4</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-batch</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.16</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.10</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </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>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.1.4</version>
        </dependency>

        <dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper</artifactId>
            <version>4.1.0</version>
        </dependency>
        <!-- <dependency>
             <groupId>org.springframework.session</groupId>
             <artifactId>spring-session-data-redis</artifactId>
         </dependency>
 -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.batch</groupId>
            <artifactId>spring-batch-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-cache</artifactId>
        </dependency>
       <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjrt</artifactId>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>
        <dependency>
            <groupId>org.xerial</groupId>
            <artifactId>sqlite-jdbc</artifactId>
            <version>3.32.3.2</version>
        </dependency>
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.7.13</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>
  • application.yml及application-dev.yml配置文件

application.yml

server:
  port: 8080
spring:
  profiles:
    active: dev
#数据库配置mysql数据库
syx:
  database:
    url: jdbc:mysql://localhost:3306/mydb?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone=UTC&allowPublicKeyRetrieval=true
    driver: com.mysql.cj.jdbc.Driver
    userName: xxxx
    passwd: xxx
    validationQuery: select 1 from dual
    initSize: 3
    minIdle: 3
    maxActive: 10
    checkTable: false
    maxWaitTime: 60000
    evictionRunTime: 60000
    minEvictionIdleTime: 300000
    keepAlive: true
    testWhileIdle: true
    testOnBorrow: true
    testOnReturn: false
    poolPreparedStatement: true
    maxPoolPreparedStatementSizePerConnection: 20
    validateQueryTimeOut: 3

application-dev.yml

mybatis:
  mapper-locations: classpath:mapper/*Mapper.xml  #mapper文件的路径
#showSql
logging:
  level:
    com:
      syx:
        dao: debug
  • 数据库配置类，主要是为了绑定application.yml中的数据库配置
package com.syx.microapplication.base;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

/**
 * @date: 2022-03-10 23:04
 * <p>数据源配置参数</p>
 */
@Component
@ConfigurationProperties(prefix = "syx.database")
public class DataSourceConfigProperty {

    private String url;

    private String driver;

    private String userName;

    private String passwd;

    private String validationQuery = "select 1 from dual";

    //连接池初始大小
    private String initSize = "3";

    //最小连接数
    private String minIdle = "3";

    //最大连接数
    private String maxActive ="10";

    //是否开启表的初始化检查
    private boolean checkTable = false;

    //获取连接的最大等待时间单位为毫秒
    private long maxWaitTime;

    //空闲检测时间单位为毫秒
    private long evictionRunTime;

    //连接在池中最小生存时间单位毫秒
    private long minEvictionIdleTime;

    //
    private boolean keepAlive;

    private boolean testWhileIdle;

    //获取连接时是否检测连接有效
    private boolean testOnBorrow;

    //连接归还时是否检测连接有效
    private boolean testOnReturn;

    //是否缓存PrepareStatement
    private boolean poolPreparedStatement;

    //每个连接的  PrepareStatement缓存大小
    private int maxPoolPreparedStatementSizePerConnection;

    //连接检测超时设置
    private int validateQueryTimeOut;
	//getters and setters....
}
  • 应用配置
package com.syx.microapplication.base;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

/**
 * @date: 2022-03-11 00:15
 * <p></p>
 */
@Configuration
@EnableAspectJAutoProxy
@ComponentScan(AppConfig.COMPONENT_SCAN)
@MapperScan(AppConfig.MAPPER_SCAN)
public class AppConfig {
    //包扫描路径
    protected static final String COMPONENT_SCAN = "com.syx";
    //mybatis的dao路径
    protected static final String MAPPER_SCAN = "com.syx.**.dao";
}
  • 数据源配置，本应用使用的是druid数据源
package com.syx.microapplication.base;

import com.alibaba.druid.pool.DruidDataSource;
import com.alibaba.druid.support.http.StatViewServlet;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.web.servlet.ServletRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.transaction.annotation.EnableTransactionManagement;

import javax.sql.DataSource;
import java.util.ArrayList;
import java.util.List;

/**
 * @date: 2022-03-10 23:01
 * <p>数据源配置</p>
 */
@Configuration
@EnableTransactionManagement
@ConditionalOnClass(DataSource.class)
public class DataSourceConfig {
    @Autowired
    private DataSourceConfigProperty dataSourceConfigProperty;
    @Bean
    @Primary
    public DruidDataSource dataSource(){
        DruidDataSource druidDataSource = new DruidDataSource();
        druidDataSource.setUrl(dataSourceConfigProperty.getUrl());
        druidDataSource.setDriverClassName(dataSourceConfigProperty.getDriver());
        druidDataSource.setUsername(dataSourceConfigProperty.getUserName());
        druidDataSource.setPassword(dataSourceConfigProperty.getPasswd());
        druidDataSource.setInitialSize(Integer.parseInt(dataSourceConfigProperty.getInitSize()));
        druidDataSource.setMinIdle(Integer.parseInt(dataSourceConfigProperty.getMinIdle()));
        druidDataSource.setMaxActive(Integer.parseInt(dataSourceConfigProperty.getMaxActive()));
        druidDataSource.setMaxWait(dataSourceConfigProperty.getMaxWaitTime());
        druidDataSource.setTimeBetweenEvictionRunsMillis(dataSourceConfigProperty.getEvictionRunTime());
        druidDataSource.setMinEvictableIdleTimeMillis(dataSourceConfigProperty.getMinEvictionIdleTime());
        druidDataSource.setTestWhileIdle(dataSourceConfigProperty.isTestWhileIdle());
        druidDataSource.setTestOnBorrow(dataSourceConfigProperty.isTestOnBorrow());
        druidDataSource.setTestOnReturn(dataSourceConfigProperty.isTestOnReturn());
        druidDataSource.setValidationQuery(dataSourceConfigProperty.getValidationQuery());
        return druidDataSource;
    }
    /**
     * druid监控平台
     * @return
     */
    @Bean
    public ServletRegistrationBean<StatViewServlet> servletRegistrationBean(){
        ServletRegistrationBean<StatViewServlet> registrationBean = new ServletRegistrationBean<>();
        StatViewServlet servlet = new StatViewServlet();
        registrationBean.setServlet(servlet);
        registrationBean.setName("druidView");
        registrationBean.setLoadOnStartup(2);
        List<String> urlMapping = new ArrayList<>();
        urlMapping.add("/druid/*");
        registrationBean.setUrlMappings(urlMapping);
        return registrationBean;
    }
}
  • quartz核心配置类QuartzConfig，该类主要是往spring容器中注入SchedulerFactoryBean，该类是quartz调度器的核心类。同时加载quartz.properyies配置文件，及维护trigger应用的xml配置文件，定义在configJobs目录下。
package com.syx.microapplication.base;

import org.quartz.*;
import org.quartz.impl.matchers.GroupMatcher;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.autoconfigure.AutoConfigureAfter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.ImportResource;
import org.springframework.context.annotation.PropertySource;
import org.springframework.core.io.ClassPathResource;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;

import javax.sql.DataSource;
import java.util.List;
import java.util.Set;

/**
 * @date: 2022-03-10 22:28
 * <p>
 *  * </p>
 */
@Configuration
@AutoConfigureAfter(DataSource.class)
@ImportResource(value = {
        "classpath*:configJobs/*ApplicationContext.xml"
})
@PropertySource(value = {
        "classpath:quartz.properties"
})
public class QuartzConfig {
    private static final Logger LOGGER = LoggerFactory.getLogger(QuartzConfig.class);


    @Bean
    public SchedulerFactoryBean schedulerFactoryBean(DataSource dataSource,QuartzTriggers quartzTriggers){
        SchedulerFactoryBean schedulerFactoryBean = new SchedulerFactoryBean(){
            @Override
            public void afterPropertiesSet() throws Exception {
                super.afterPropertiesSet();
                //项目启动时打印任务信息
                triggerMsgPrint(super.getScheduler());
            }
        };
        //配置数据源
        schedulerFactoryBean.setDataSource(dataSource);
        //设置quartz.properties
        schedulerFactoryBean.setConfigLocation(new ClassPathResource("quartz.properties"));
       //设置任务自启动
        schedulerFactoryBean.setAutoStartup(true);
        //设置调度器名称
        schedulerFactoryBean.setSchedulerName("SYX_SCHEDULER");
        
        //triggers维护在configJobs/*ApplicationContext.xml的文件中
        schedulerFactoryBean.setTriggers(quartzTriggers.getTriggers());
        schedulerFactoryBean.setOverwriteExistingJobs(true);
        return schedulerFactoryBean;
    }


    /**
     * 打印trigger信息
     * @param scheduler
     */
    private void triggerMsgPrint(Scheduler scheduler) throws SchedulerException {

        List<String> groupNames = scheduler.getTriggerGroupNames();

        for (String groupName : groupNames) {

            Set<TriggerKey> triggerKeys = scheduler.getTriggerKeys(GroupMatcher.triggerGroupEquals(groupName));

            for (TriggerKey triggerKey : triggerKeys) {

                Trigger trigger = scheduler.getTrigger(triggerKey);

                JobDetail jobDetail = scheduler.getJobDetail(trigger.getJobKey());
                //在使用java配置job时需要指定key为JobName
                LOGGER.info("任务名->{}",jobDetail.getJobDataMap().getString("JobName"));
                LOGGER.info("任务描述->{}",jobDetail.getDescription());
                //需要指定  默认指定为0
                LOGGER.info("重复执行次数->{}",jobDetail.getJobDataMap().getString("RepeatTime"));
                //需要指定 默认为10ms 维护在JobDataMap
                LOGGER.info("重跑时间间隔->{}",jobDetail.getJobDataMap().getString("RepeatInterval"));
                if(trigger instanceof CronTrigger){
                    CronTrigger temp = (CronTrigger) trigger;
                    LOGGER.info("cron表达式->{}",temp.getCronExpression());
                    LOGGER.info("开始执行时间->{}",temp.getStartTime());
                }
                if(trigger instanceof SimpleTrigger){
                    SimpleTrigger temp = (SimpleTrigger) trigger;
                    LOGGER.info("触发时间->{}",temp.getFinalFireTime());
                    LOGGER.info("开始执行时间->{}",temp.getStartTime());
                }
                LOGGER.info("下次执行时间->{}",trigger.getNextFireTime());
            }
        }
    }
}
  • QuartzTriggers配置类与configJobs/*ApplicationContext.xml对应，用于维护triggers
package com.syx.microapplication.base;
import org.quartz.Trigger;
import java.util.List;
/**
 * @date: 2022-03-11 20:49
 * <p>维护triggers</p>
 */
public class QuartzTriggers {
    private List<Trigger> triggers;
    public Trigger[] getTriggers(){
        Trigger[] arr = new Trigger[this.triggers.size()];
        for (int i = 0; i < this.triggers.size(); i++) {
            arr[i] = this.triggers.get(i);
        }
        return arr;
    }
    public void setTriggers(List<Trigger> triggers) {
        this.triggers = triggers;
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns= "http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd">
 <!--加载任务trigger-->
    <import resource="classpath*:configJobs/jobs/*ApplicationContext.xml"/>
    <!--将加载的任务trigger维护到QuartzTriggers的list中-->
    <bean id="triggerCollection" class="com.syx.microapplication.base.QuartzTriggers">
        <property name="triggers">
            <list>
                <ref bean="TestJobTrigger"/>
            </list>
        </property>
    </bean>
</beans>
  • 启动类，启动类中我们要排除springboot的quartz自动配置，进而使用我们自定义的SchedulerFactoryBean 的配置。查看QuartzAutoConfiguration源码亦可知，该类的主要作用为，往容器中注入了SchedulerFactoryBean。
package com.syx.microapplication;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.quartz.QuartzAutoConfiguration;
/**
 - @date: 2022-03-10 23:49
 - <p></p>
 */
@SpringBootApplication(exclude = {QuartzAutoConfiguration.class})
public class MainApp {
    public static void main(String[] args) {
        SpringApplication.run(MainApp.class,args);
    }
}

三、新建 job

  • 新建测试job该任务必须实现org.quartz.Job接口。
package com.syx.demon.job;
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
/**
 * @date: 2022-03-11 21:53
 * <p></p>
 */
public class TestJob implements Job {
    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        System.out.println("Hello world...");
    }
}
  • 新建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-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--自定义job任务-->
    <bean id="TestJob" class="com.syx.demon.job.TestJob"/>
    <!--job任务纳管到JobDetailFactoryBean类中-->
    <bean id="TestJobName" class="org.springframework.scheduling.quartz.JobDetailFactoryBean">
        <property name="description" value="TestJob测试"/>
        <property name="group" value="TestJobGroup"/>
        <property name="jobClass" value="com.syx.demon.job.TestJob"/>
        <property name="durability" value="true"/>
        <property name="jobDataAsMap">
            <map>
                <entry key="JobName" value="TestJob"/>
                <entry key="RepeatTime" value="0"/>
                <entry key="RepeatInterval" value="10"/>
            </map>
        </property>
    </bean>
<!--将JobDetailFactoryBean配置到CronTriggerFactoryBean中，并指定cron表达式-->
    <bean id="TestJobTrigger" class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">
        <property name="jobDetail" ref="TestJobName"/>
        <property name="cronExpression" value="*/30 * * * * ?"/>
        <!--错过是否补跑 0，1是 2 否-->
        <property name="misfireInstruction" value="2"/>
    </bean>
</beans>

四、启动工程

控制台打印了任务信息，同时任务也执行并输出了hello world…
在这里插入图片描述

数据库中记录了任务名，任务组及任务的class信息。
在这里插入图片描述

五、quartz扩展，通过http请求控制任务启停。

  • 新建quartz任务调度控制service
package com.syx.microapplication.system.service;

import com.syx.microapplication.system.bean.QuartzJobDetail;
import org.quartz.*;
import org.quartz.impl.matchers.GroupMatcher;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;
import java.util.Set;

/**
 * @date: 2022-03-12 16:20
 * <p></p>
 */
@Service
public class QuartzSchedulerService {
    @Autowired
    private Scheduler scheduler;
    private static final Logger LOGGER = LoggerFactory.getLogger(QuartzSchedulerService.class);

    /**
     * 查询所有任务
     * @return
     * @throws SchedulerException
     */
    public List<QuartzJobDetail> getJobDetail() throws SchedulerException {
        List<QuartzJobDetail> result = new ArrayList<>();

        List<String> groupNames = scheduler.getJobGroupNames();
        for (String groupName : groupNames) {

            Set<JobKey> jobKeys = scheduler.getJobKeys(GroupMatcher.jobGroupEquals(groupName));

            for (JobKey jobKey : jobKeys) {

                JobDetail jobDetail = scheduler.getJobDetail(jobKey);
                QuartzJobDetail jobInfo = new QuartzJobDetail();
                jobInfo.setSchedulerName(scheduler.getSchedulerName());
                jobInfo.setSchedulerInstanceId(scheduler.getSchedulerInstanceId());
                jobInfo.setJobName(jobKey.getName());
                jobInfo.setDescription(jobDetail.getDescription());
                jobInfo.setDurability(jobDetail.isDurable());
                jobInfo.setRecover(jobDetail.requestsRecovery());
                jobInfo.setGroup(jobKey.getGroup());
                jobInfo.setJobClass(jobDetail.getJobClass().getName());
                List<? extends Trigger> triggers = scheduler.getTriggersOfJob(jobKey);

                if(triggers!=null && !triggers.isEmpty()){

                    for (Trigger trigger : triggers) {
                        jobInfo.setState(scheduler.getTriggerState(trigger.getKey()).name());
                        jobInfo.setTriggersNum(triggers.size());
                        jobInfo.setNextFireTime(trigger.getNextFireTime());
                    }
                }else{
                    jobInfo.setState("NONE");
                }
                result.add(jobInfo);
            }
        }

        return result;
    }


    /**
     * 删除job
     * @param jobName
     * @param jobGroup
     * @throws SchedulerException
     */
    public void deleteJob(String jobName,String jobGroup) throws SchedulerException {
        scheduler.deleteJob(JobKey.jobKey(jobName,jobGroup));
    }


    /**
     * 重启job
     * @param jobName
     * @param jobGroup
     * @throws SchedulerException
     */
    public void resumeJob(String jobName,String jobGroup) throws SchedulerException {
        scheduler.resumeJob(JobKey.jobKey(jobName,jobGroup));
    }


    /**
     * 暂停job
     * @param jobName
     * @param jobGroup
     * @throws SchedulerException
     */
    public void pause(String jobName,String jobGroup) throws SchedulerException {
        scheduler.pauseJob(JobKey.jobKey(jobName,jobGroup));
    }

    /**
     * 立即执行
     * @param jobName
     * @param jobGroup
     * @throws SchedulerException
     */
    public void triggerNow(String jobName,String jobGroup) throws SchedulerException {
        scheduler.triggerJob(JobKey.jobKey(jobName,jobGroup));
    }
}
  • 任务详情包装类
package com.syx.microapplication.system.bean;

import com.syx.utils.IDUtil;

import java.util.Date;
import java.util.Map;

/**
 * @date: 2022-03-12 15:40
 * <p>quartzJob的描述信息</p>
 */
public class QuartzJobDetail {

    private String description;

    private boolean durability;

    private String group;

    private String jobClass;

    private Map<String,Object> jobDataMap;

    private String jobName;

    private Date nextFireTime;

    private int triggersNum;

    private String quartzInstanceId;

    private String schedulerInstanceId;

    private String schedulerName;

    private boolean recover;

    private String state;

    private String uuid=IDUtil.generateId();

	//getters and setters
}
  • 任务调度controller
package com.syx.microapplication.system.controller;

import com.syx.microapplication.system.bean.QuartzJobDetail;
import com.syx.microapplication.system.service.QuartzSchedulerService;
import org.quartz.SchedulerException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.List;
/**
 * @date: 2022-03-12 15:31
 * <p></p>
 */
@RestController
@RequestMapping("/quartzJob")
public class QuartzJobController {

    @Autowired
    private QuartzSchedulerService quartzSchedulerService;
    private static final Logger LOGGER = LoggerFactory.getLogger(QuartzJobController.class);

    @GetMapping
    public List<QuartzJobDetail> getJobDetail() throws SchedulerException {
        return quartzSchedulerService.getJobDetail();
    }

    /**
     * 删除job
     * @param jobName
     * @param jobGroup
     * @throws SchedulerException
     */
    @DeleteMapping
    public void deleteJob(String jobName,String jobGroup) throws SchedulerException {
        quartzSchedulerService.deleteJob(jobName,jobGroup);
        LOGGER.info("删除任务{}成功",jobName);
    }


    /**
     * 重启job
     * @param jobName
     * @param jobGroup
     * @throws SchedulerException
     */
    @GetMapping(path = "{jobName}/{jobGroup}/resume")
    public void resumeJob(@PathVariable(value = "jobName") String jobName,
                          @PathVariable(value = "jobGroup") String jobGroup) throws SchedulerException {
        quartzSchedulerService.resumeJob(jobName,jobGroup);
        LOGGER.info("重启任务{}成功",jobName);
    }


    /**
     * 暂停job
     * @param jobName
     * @param jobGroup
     * @throws SchedulerException
     */
    @GetMapping(path = "{jobName}/{jobGroup}/pause")
    public void pause(@PathVariable(value = "jobName") String jobName,
                      @PathVariable(value = "jobGroup") String jobGroup) throws SchedulerException {
       quartzSchedulerService.pause(jobName,jobGroup);
       LOGGER.info("暂停任务{}成功",jobName);
    }

    /**
     * 立即执行
     * @param jobName
     * @param jobGroup
     * @throws SchedulerException
     */
    @GetMapping(path = "{jobName}/{jobGroup}/triggerNow")
    public void triggerNow(@PathVariable(value = "jobName") String jobName,
                           @PathVariable(value = "jobGroup") String jobGroup) throws SchedulerException {
        quartzSchedulerService.triggerNow(jobName,jobGroup);
        LOGGER.info("任务{}启动成功",jobName);
    }
}

六、总结

屎壳郎推球球
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
spring整合quartz使用jdbc存储
08-03
spring整合quartz使用jdbc存储任务，并配置为quartz集群应用
springboot集成quartz完成定时任务+数据库存储
qq_45384482的博客
12-07 1682
文章目录前言Spring整合Quartz读取数据库启动定时任务 前言 注意：本篇博客采取的是spring自带的定时器与quartz调度框架一并使用，不涉及到页面。 项目层次： Spring整合Quartz quartz调度框架是有内置表的，进入quartz的官网http://www.quartz-scheduler.org/，点击Downloads，下载后在目录\docs\dbTables下有常用数据库创建quartz表的脚本，找到tables_mysql.sql导入到数据库。 这些表是操作quartz
Quartz定时任务配置参数的含义
最新发布
weixin_36873225的博客
07-18 484
例如，在一个分布式系统中，可以为每个节点的Quartz调度器设置不同的instanceName，以避免节点之间的任务冲突和重复执行。用于指定Quartz调度器的任务触发器的misfire阈值。例如，在一个分布式系统中，可以为每个节点的Quartz调度器设置不同的instanceId，以避免节点之间的任务冲突和重复执行。② AUTO:如果属性设置为Auto，则Quartz调度器会自动为每个实例分配一个唯一的instanceId，Quartz调度器会根据当前时间和随机数生成一个唯一的instanceId。
定时任务知多少（二）——持久化quartz到Mongodb中
实鼠不疫,牛转乾坤
09-30 1万+
上文中，我们粗劣的介绍定时任务相关的知识。并且，我们初步了解了 Spring+quartz 的初步应用：将quartz放在内存中。 通过上文的分析，我们很容易看清：该种方式实现定时任务，较为简单，实现的功能也较为粗劣。由于我们直接把quartz放入内存中，等待执行；我们无法在它执行之前对它进行操作，比如任务暂停、删除等等。 今天，我们就来继续介绍可序列化的quartz的deno。
SpringBoot集成quartz定时调度任务并通过JDBC持久化
OPENTHED00R的博客
06-01 534
SpringBoot集成quartz定时调度任务并通过JDBC持久化话不多说上干货项目pom依赖配置类抽象出调度任务实体类插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 话不多说上干货 xxx项目中有很多定时任务用于生产环境中在特殊时间点执行大批量数据聚合的任务，出于负载均衡的要求，我们的
Spring Boot 2.x 集成 Quartz 定时器 jdbc 持久化、配置集群
蚩尤后裔-汪茂雄
04-13 8259
目录 RAMJobStore 内存持久化 jdbcjobstore 数据库持久化 jdbcjobstore 数据库持久化 Spring Boot 集成 Quartz 定时器
Spring整合Quartz案例使用JDBC存储方式
z1340954953
08-02 3030
目录 创建数据库表 配置数据库连接池 创建工作类 工作类中调用的业务类  工作类 配置JobDetail和Trigger，并交给Scheduler注册 测试 Quartz集群中如何工作 Quartz集群环境下配置 quartz.properties 工作类 SchedulerFactory的xml配置 JobDetail的xml配置 测试集群 quartz水平集群和垂...
springboot整合quartz定时任务yml文件配置方式
03-23
在Spring Boot应用中整合Quartz定时任务是一种常见的需求，它可以帮助我们执行周期性的后台任务，如数据同步、报表生成等。Spring Boot与Quartz的结合提供了便捷的配置方式，特别是通过YAML（YAML Ain't Markup ...
springboot整合quartz，实现数据库方式执行定时任务
11-19
本篇将详细介绍如何在Spring Boot项目中整合Quartz，以数据库存储的方式实现定时任务。 首先，我们需要在项目中引入Quartz和Spring Boot的依赖。在`pom.xml`文件中添加以下依赖： ```xml <groupId>org.spring...
SpringBoot2.0整合Quartz定时任务,实现基于数据库如mysql的动态任务
12-27
在Spring Boot 2.0中整合Quartz定时任务，可以实现基于数据库如MySQL的动态任务管理，这在很多需要周期性执行任务的应用场景中非常实用。以下将详细讲解这一过程。 首先，我们要在项目的`pom.xml`文件中添加Quartz...
SpringBoot整合quartz2.2.3自定义数据源和websocket通信
03-21
综上所述，SpringBoot整合quartz 2.2.3和WebSocket通信是一项综合性的任务，涉及到数据库管理、定时任务调度和实时通信等多个领域。通过恰当的配置和编程，我们可以构建出高效、可扩展的微服务系统，满足复杂的企业...
springboot整合Quartz.zip
02-21
SpringBoot整合Quartz是一个常见的需求，它允许开发者在SpringBoot应用中轻松地创建和管理定时任务。Quartz是一个开源的作业调度框架，它为Java应用程序提供了丰富的调度功能。接下来，我们将详细探讨如何将Quartz与...
quartz持久化进DB
tby415的博客
12-27 370
项目中涉及到定时任务，quartz应用广泛，大部分项目只用到它的内存持久化模式，如果想在不重启应用的情况下实时修改job执行时间，就涉及到quartz的DB持久化。 .首先根据数据库的不同建立框架所需的表，建表语句自行百度，这里不多做记录。 **1..环境信息：springboot 2.1.0** quartz依赖： &amp;amp;amp;amp;amp;lt;dependency&amp;amp;amp;amp;amp;gt; &amp;amp;amp
Spring Boot 集成Quartz
qq_19891197的博客
02-05 4958
Spring Boot 集成Quartz
Quartz与SpringBoot 搞定任务调度
热门推荐
houxian1103的博客
02-19 1万+
Quartz是OpenSymphony开源组织在Job scheduling领域又一个开源项目，它可以与J2EE与J2SE应用程序相结合也可以单独使用。Quartz可以用来创建简单或为运行十个，百个，甚至是好几万个Jobs这样复杂的程序。Jobs可以做成标准的Java组件或 EJBs。Quartz的最新版本为Quartz 2.3.2JobJob是一个任务接口，开发者定义自己的任务须实现该接口，并重写execute(JobExecutionContext context)方法.
SpringBoot - 集成Quartz框架之常见问题(五)
记录并分享
09-26 2331
SpringBoot集成Quartz框架时遇到的常见问题。
SpringBoot2.0整合Quartz(JDBC)+Druid连接池遇到的一些坑
Allisam的博客
08-02 1746
SpringBoot2.0整合Quartz(JDBC)+Druid连接池遇到的一些坑
实现CronExpression的getFinalFireTime(),写的急，大家再改改！
wv112406的博客
11-03 616
class MyCronExpr extends CronExpression { /** * 返回最后一次执行的时间; * @return */ public Date getFinalFireTime() { Calendar ret = Calendar.getInstance(); In...
SpringBoot整合Quartz定时任务（持久化到数据库）_spring boot集成quartz并将数据持久化到数据库
2401_85012088的博客
05-16 1167
所以决定采用 JDBC作业存储的方式。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值