springboot整合quartz定时任务，并实现动态动态管理，实现调用service注入。

最新推荐文章于 2024-05-13 22:56:21 发布

置顶逆流的小白

最新推荐文章于 2024-05-13 22:56:21 发布

阅读量1.8k

点赞数

分类专栏： springboot quartz

本文链接：https://blog.csdn.net/qq_43566496/article/details/103595436

版权

springboot 同时被 2 个专栏收录

4 篇文章 0 订阅

订阅专栏

quartz

1 篇文章 0 订阅

订阅专栏

1.创建一个boot项目

创建一个简单的boot项目，加入web，和mysql的依赖。此处不赘述。
项目结构图：

在这里插入图片描述

2.依赖

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

3.配置

在这里插入图片描述

1.sql的xml文件，根据你定义的实体类写。

2.数据库等

application.properties

#mysql数据库
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.password=1234
spring.datasource.username=admin
#spring.datasource.url=jdbc:mysql://127.0.0.1:3306/drl?useUnicode=true&characterEncoding=utf-8&serverTimezone=GMT%2B8
spring.datasource.url=jdbc:mysql://47.102.143.37:3306/drl?useUnicode=true&characterEncoding=utf-8&serverTimezone=GMT%2B8
#转化时区，用于展示数据
spring.jackson.date-format=yyyy-MM-dd HH:mm:ss
spring.jackson.time-zone=GMT+8
#log配置
logging.file.name=/data/log/sysadmin.log
logging.file.max-size=10MB
logging.file.max-history=7
logging.pattern.dateformat=yyyy-MM-dd hh:mm:ss SSS

#项目入口名称
#端口号、入口名称
server.port=8081
server.servlet.context-path=/sysadmin
#扫描xml文件
mybatis.mapper-locations=classpath:com/sysadmin/mapper/*.xml

application-quartz.properties

#整合quartz
spring.quartz.properties.org.quartz.scheduler.instanceName=aQuartzScheduler
spring.quartz.properties.org.quartz.scheduler.instanceId=AUTO
spring.quartz.properties.org.quartz.scheduler.rmi.export=false
spring.quartz.properties.org.quartz.scheduler.rmi.proxy=false
spring.quartz.properties.org.quartz.scheduler.wrapJobExecutionInUserTransaction=false

spring.quartz.properties.org.quartz.jobStore.misfireThreshold=50000
spring.quartz.properties.org.quartz.jobStore.class=org.quartz.impl.jdbcjobstore.JobStoreTX
spring.quartz.properties.org.quartz.jobStore.driverDelegateClass=org.quartz.impl.jdbcjobstore.StdJDBCDelegate
spring.quartz.properties.org.quartz.jobStore.tablePrefix=QRTZ_
spring.quartz.properties.org.quartz.jobStore.isClustered=true
spring.quartz.properties.org.quartz.jobStore.useProperties=false
spring.quartz.properties.org.quartz.jobStore.clusterCheckinInterval=20000

spring.quartz.properties.org.quartz.threadPool.class=org.quartz.simpl.SimpleThreadPool
spring.quartz.properties.org.quartz.threadPool.threadCount=10
spring.quartz.properties.org.quartz.threadPool.threadPriority=5
spring.quartz.properties.org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread=true
# 数据库方式
spring.quartz.job-store-type=jdbc

配置完成

3.开始定义

1.工具类

用于service根据名字注入

**
 * @Description
 * @date 2019/11/17 9:04
 * @since JDK1.8
 **/
@Component
public class SpringContextUtil implements ApplicationContextAware {

    private static ApplicationContext applicationContext;     //Spring应用上下文环境

    /**
     * 实现ApplicationContextAware接口的回调方法，设置上下文环境
     *
     * @param applicationContext
     * @throws BeansException
     */
    @Autowired
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {

        SpringContextUtil.applicationContext = applicationContext;
    }

    /**
     * @return ApplicationContext
     */
    public static ApplicationContext getApplicationContext() {

        return SpringContextUtil.applicationContext;
    }

    /**
     * 获取对象
     *
     * @param name
     * @return Object 一个以所给名字注册的bean的实例
     * @throws BeansException
     */
    public static Object getBean(String name) throws BeansException {

        if (applicationContext != null) {
            return applicationContext.getBean(name);
        } else {
            return null;
        }
    }
    }

2.quartz

SpringJobFactory 解决job中service注入为空的问题。

/**
 * @authorl
 * @Description 解决job中service注入为空的问题。
 * @date 2019/12/17 0017 10:35
 * @since JDK1.8
 **/
@Component
public class SpringJobFactory extends AdaptableJobFactory {

    @Autowired
    private AutowireCapableBeanFactory capableBeanFactory;

    @Override
    protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception {
        //调用父类的方法
        Object jobInstance = super.createJobInstance(bundle);
        //进行注入
        capableBeanFactory.autowireBean(jobInstance);
        return jobInstance;
    }

}

/**
 * @Description 定时任务配置，注入必要的bean
 * @date 2019/12/17 0017 10:46
 * @since JDK1.8
 **/
@Configuration
public class QuartzConfig {

    /**
     * 重写AdaptableJobFactory，解决service注入为null的问题
     */
    @Autowired
    private SpringJobFactory springJobFactory;

    @Bean
    public SchedulerFactoryBean schedulerFactoryBean() {
        SchedulerFactoryBean schedulerFactoryBean = new SchedulerFactoryBean();
        schedulerFactoryBean.setJobFactory(springJobFactory);
        return schedulerFactoryBean;
    }

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

3.调度中心

/**
 * @author
 * @Description 调度中心
 * @date 2019/12/16 0016 17:26
 * @since JDK1.8
 **/
@Configuration
public class QuartzScheduler {
    // 任务调度
    @Autowired
    private Scheduler scheduler;

    /**
     * 开启某个任务
     *
     * @param taskDao 任务对象
     * @throws
     */
    public void startJob(TaskDao taskDao) throws SchedulerException {
        String name = taskDao.getServiceName();
        String group = taskDao.getTaskType().name();
        String time = taskDao.getCronExpression();
        // 通过JobBuilder构建JobDetail实例，JobDetail规定只能是实现Job接口的实例
        // JobDetail 是具体Job实例
        AbstractTask abstractTask = (AbstractTask) SpringContextUtil.getBean(name);
        JobDetail jobDetail = JobBuilder.newJob(abstractTask.getClass()).withIdentity(name, group).build();
        // 基于表达式构建触发器
        CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule(time);
        // CronTrigger表达式触发器 继承于Trigger
        // TriggerBuilder 用于构建触发器实例
        CronTrigger cronTrigger = TriggerBuilder.newTrigger().withIdentity(name, group)
                .withSchedule(cronScheduleBuilder).build();
        // CronTrigger表达式触发器 继承于Trigger
        // TriggerBuilder 用于构建触发器实例
//        CronTrigger cronTrigger = TriggerBuilder.newTrigger().withIdentity(name, group)
//                .withSchedule(CronScheduleBuilder.cronSchedule(time).withMisfireHandlingInstructionIgnoreMisfires()).build();
        scheduler.scheduleJob(jobDetail, cronTrigger);
    }

    /**
     * 删除某个任务
     *
     * @param taskDao 任务对象
     * @throws
     */
    public void deleteJob(TaskDao taskDao) throws SchedulerException {
        JobKey jobKey = new JobKey(taskDao.getServiceName(), taskDao.getTaskType().name());
        JobDetail jobDetail = scheduler.getJobDetail(jobKey);
        if (jobDetail == null)
            return;
        scheduler.deleteJob(jobKey);
    }

    /**
     * 获取Job信息
     *
     * @param taskDao
     * @return
     * @throws
     */
    public String getJobInfo(TaskDao taskDao) throws SchedulerException {
        TriggerKey triggerKey = new TriggerKey(taskDao.getServiceName(), taskDao.getTaskType().name());
        CronTrigger cronTrigger = (CronTrigger) scheduler.getTrigger(triggerKey);
        return String.format("time:%s,state:%s", cronTrigger.getCronExpression(),
                scheduler.getTriggerState(triggerKey).name());
    }

    /**
     * 修改某个任务的执行时间
     *
     * @param taskDao 任务对象
     * @return
     * @throws
     */
    public boolean modifyJob(TaskDao taskDao) throws SchedulerException {
        Date date = null;
        TriggerKey triggerKey = new TriggerKey(taskDao.getServiceName(), taskDao.getTaskType().name());
        CronTrigger cronTrigger = (CronTrigger) scheduler.getTrigger(triggerKey);
        String oldTime = cronTrigger.getCronExpression();
        if (!oldTime.equalsIgnoreCase(taskDao.getCronExpression())) {
            CronTrigger trigger = TriggerBuilder.newTrigger().withIdentity(taskDao.getServiceName(), taskDao.getTaskType().name())
                    .withSchedule(CronScheduleBuilder.cronSchedule(taskDao.getCronExpression()).withMisfireHandlingInstructionIgnoreMisfires())
                    .build();
            date = scheduler.rescheduleJob(triggerKey, trigger);
        }
        return date != null;
    }

    /**
     * 暂停所有任务
     *
     * @throws
     */
    public void pauseAllJob() throws SchedulerException {
        scheduler.pauseAll();
    }

    /**
     * 暂停某个任务
     *
     * @param taskDao 任务对象
     * @throws
     */
    public void pauseJob(TaskDao taskDao) throws SchedulerException {
        JobKey jobKey = new JobKey(taskDao.getServiceName(), taskDao.getTaskType().name());
        JobDetail jobDetail = scheduler.getJobDetail(jobKey);
        if (jobDetail == null)
            return;
        scheduler.pauseJob(jobKey);
    }

    /**
     * 恢复所有任务
     *
     * @throws
     */
    public void resumeAllJob() throws SchedulerException {
        scheduler.resumeAll();
    }

    /**
     * 恢复某个任务
     *
     * @param taskDao 任务对象
     * @throws
     */
    public void resumeJob(TaskDao taskDao) throws SchedulerException {
        JobKey jobKey = new JobKey(taskDao.getServiceName(), taskDao.getTaskType().name());
        JobDetail jobDetail = scheduler.getJobDetail(jobKey);
        if (jobDetail == null)
            return;
        scheduler.resumeJob(jobKey);
    }
}

从调度重新的startJob方法，可以看出TaskDao的属性。TaskDao的创建啥的就自己写咯，都是千篇一律的service，controller之类。需要注意的是在创建修改TaskDao对象是，要对任务进行对应的start和stop操作。如更新时，需要把任务delete了，更新库之后再start。
String name = taskDao.getServiceName();（注入的servicename）
String group = taskDao.getTaskType().name();（任务分组，这个可以一样）
String time = taskDao.getCronExpression();（cron表达式）
如每天9-16点每3秒执行一次：0/3 * 9-16 * * ?

提供一个cron表达式工具：
链接：https://pan.baidu.com/s/1Kh9d2EuPVjFq8lIz9wiRBA
提取码：5xhy
复制这段内容后打开百度网盘手机App，操作更方便哦

逆流的小白

关注

0
点赞
踩
7

收藏

觉得还不错? 一键收藏
0
评论
springboot整合quartz定时任务，并实现动态动态管理，实现调用service注入。

1.创建一个boot项目创建一个简单的boot项目，加入web，和mysql的依赖。此处不赘述。项目结构图：![在这里插入图片描述](https://img-blog.csdnimg.cn/20191218140228112.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly...
复制链接

扫一扫