springboot整合定时任务

最新推荐文章于 2024-05-10 22:15:27 发布
最新推荐文章于 2024-05-10 22:15:27 发布
阅读量343 收藏 1
点赞数
分类专栏： java 文章标签： spring boot java intellij-idea
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wqww_1/article/details/125187042
版权

pom.xml配置文件信息

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

创建数据库

CREATE TABLE `cc_task_info` (
  `TID` int(11) NOT NULL AUTO_INCREMENT,
  `TASK_ANME` varchar(50) NOT NULL,
  `TASK_CODE` varchar(50) NOT NULL,
  `JOB_CLASS` varchar(200) NOT NULL,
  `JOB_GROUP` varchar(50) NOT NULL,
  `CRON` varchar(50) NOT NULL,
  `DEL_STATUS` varchar(2) DEFAULT '1' NULL,
  `CRT_TIME` datetime DEFAULT NULL,
  PRIMARY KEY (`TID`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8 COMMENT='定时任务管理表';

对cc_task_info的增删改查

CcTaskInfo

package com.shengun.quartz.entity;

import com.baomidou.mybatisplus.annotation.IdType;
import java.util.Date;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableField;
import java.io.Serializable;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;

/**
 * <p>
 * 定时任务管理表
 * </p>
 *
 * @author shengun
 * @since 2022-06-08
 */
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@ApiModel(value="CcTaskInfo对象", description="定时任务管理表")
public class CcTaskInfo implements Serializable {

    private static final long serialVersionUID = 1L;

    @TableId(value = "TID", type = IdType.AUTO)
    private Integer tid;

    @TableField("TASK_ANME")
    private String taskAnme;

    @TableField("TASK_CODE")
    private String taskCode;

    @TableField("JOB_CLASS")
    private String jobClass;

    @TableField("JOB_GROUP")
    private String jobGroup;

    @TableField("CRON")
    private String cron;

    @TableField("DEL_STATUS")
    private String delStatus;

    @TableField("CRT_TIME")
    private Date crtTime;

}

CcTaskInfoService

package com.shengun.quartz.service;

import com.shengun.quartz.entity.CcTaskInfo;
import com.baomidou.mybatisplus.extension.service.IService;

import java.util.List;

/**
 * <p>
 * 定时任务管理表 服务类
 * </p>
 *
 * @author shengun
 * @since 2022-06-08
 */
public interface CcTaskInfoService extends IService<CcTaskInfo> {

    //增
    public void addTaskInfo(CcTaskInfo ccTaskInfo);

    //删除
    public void delTaskInfo(int id);

    //改
    public void updateTaskInfo(CcTaskInfo ccTaskInfo);

    //查
    public List<CcTaskInfo> getTaskInfo();

}

CcTaskInfoServiceImpl

package com.shengun.quartz.service.impl;

import com.shengun.quartz.entity.CcTaskInfo;
import com.shengun.quartz.mapper.CcTaskInfoMapper;
import com.shengun.quartz.service.CcTaskInfoService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.shengun.quartz.service.QuartzService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.transaction.Transactional;
import java.util.List;

/**
 * <p>
 * 定时任务管理表 服务实现类
 * </p>
 *
 * @author shengun
 * @since 2022-06-08
 */
@Service
public class CcTaskInfoServiceImpl extends ServiceImpl<CcTaskInfoMapper, CcTaskInfo> implements CcTaskInfoService {

    @Autowired
    private QuartzService quartzService;

    @Transactional
    @Override
    public void addTaskInfo(CcTaskInfo ccTaskInfo) {
        //现在数据库中添加详细信息
        int insert = this.baseMapper.insert(ccTaskInfo);
        if(insert>0){
            //在启动定时任务
            try {
                quartzService.startJob(ccTaskInfo.getTaskCode(),
                        ccTaskInfo.getTaskAnme(),
                        ccTaskInfo.getCron(),
                        ccTaskInfo.getJobGroup(),
                        ccTaskInfo.getJobClass());
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    @Override
    public void delTaskInfo(int id) {
        this.baseMapper.deleteById(id);
    }

    @Override
    public void updateTaskInfo(CcTaskInfo ccTaskInfo) {
        this.baseMapper.updateById(ccTaskInfo);
    }

    @Override
    public List<CcTaskInfo> getTaskInfo() {
        return this.baseMapper.selectList(null);
    }

}

CcTaskInfoController

package com.shengun.quartz.controller;


import com.shengun.annotation.OperationAnnotation;
import com.shengun.quartz.entity.CcTaskInfo;
import com.shengun.quartz.service.CcTaskInfoService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * <p>
 * 定时任务管理表 前端控制器
 * </p>
 *
 * @author shengun
 * @since 2022-06-08
 */
@RestController
@RequestMapping("/quartz/cc-task-info")
public class CcTaskInfoController {

    @Autowired
    private CcTaskInfoService ccTaskInfoService;

    @GetMapping("/list")
    @OperationAnnotation
    public Map<String,Object> getTaskInfos(){
        Map<String, Object> map = new HashMap<>();
        map.put("code", 200);
        map.put("msg", "查询成功");
        List<CcTaskInfo> taskInfos = ccTaskInfoService.getTaskInfo();
        map.put("list",taskInfos);
        return map;
    }

    @PostMapping("/add")
    @OperationAnnotation
    public Map<String,Object> addTaskInfo(@RequestBody CcTaskInfo ccTaskInfo){
        Map<String, Object> map = new HashMap<>();
        map.put("code", 200);
        map.put("msg", "添加成功");
        if(ccTaskInfo.getCron() == null){
            return null;
        }
        ccTaskInfo.setCrtTime(new Date());
        ccTaskInfoService.addTaskInfo(ccTaskInfo);
        map.put("flag", true);
        return map;
    }
}

定时任务配置文件QuartzConfig

package com.shengun.quartz.config;

import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SchedulerFactory;
import org.quartz.impl.StdSchedulerFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class QuartzConfig {
    @Bean
    public Scheduler scheduler(){
        Scheduler scheduler = null;
        SchedulerFactory factory = new StdSchedulerFactory();
        try {
            scheduler = factory.getScheduler();
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
        if(scheduler != null){
            try {
                //启动定时任务
                scheduler.start();
            } catch (SchedulerException e) {
                e.printStackTrace();
            }
        }
        return scheduler;
    }
}

QuartzService定时任务服务

package com.shengun.quartz.service;

import com.shengun.quartz.entity.CcTaskInfo;
import org.quartz.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.annotation.PostConstruct;
import java.util.Date;
import java.util.List;

/**
 * 定时任务管理服务
 */
@Service
public class QuartzService {

    public static String SCHEDULER_OPR_START = "start";
    public static String SCHEDULER_OPR_PAUSE = "pause";
    public static String SCHEDULER_OPR_RESUME = "resume";
    public static String SCHEDULER_OPR_REMOVE = "remove";

    @Autowired
    private CcTaskInfoService ccTaskInfoService;

    @Autowired
    private Scheduler scheduler;

    /**
     * 项目启动的时候初始化
     */
    @PostConstruct
    public void init(){
        List<CcTaskInfo> taskInfo = ccTaskInfoService.getTaskInfo();
        for (CcTaskInfo ccTaskInfo : taskInfo) {
            if(ccTaskInfo.getDelStatus().equals("1")){
                System.out.println("#######可以启动：" + ccTaskInfo.getTaskAnme());
                try {
                    startJob(ccTaskInfo.getTaskCode(),
                            ccTaskInfo.getTaskAnme(),
                            ccTaskInfo.getCron(),
                            ccTaskInfo.getJobGroup(),
                            ccTaskInfo.getJobClass());
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * 启动任务
     */
    public void startJob(String taskCode, String taskAnme, String cron, String jobGroup,
                         String className) throws Exception{
        Class<Job> jobClass = null;
        try {
            jobClass = (Class<Job>) Class.forName(className);//获取任务执行类
        } catch (ClassNotFoundException e) {
            throw new Exception("任务类不存在");
        }
        //创建job，指定job名称和分组
        JobDetail jobDetail = JobBuilder.newJob(jobClass).withIdentity(taskCode, jobGroup).build();
        //创建表达式工作计划
        CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule(cron);
        //创建触发器
        CronTrigger cronTrigger = TriggerBuilder.newTrigger().withIdentity(taskCode, jobGroup)
                .withSchedule(cronScheduleBuilder).build();
        scheduler.scheduleJob(jobDetail, cronTrigger);
    }

    /**
     * 修改定时任务执行时间
     * @param taskCode
     * @param jobGroup
     * @param cron 新的时间
     * @throws Exception
     */
    public void modifyJob(String taskCode, String jobGroup, String cron) throws Exception{
        TriggerKey triggerKey = new TriggerKey(taskCode, jobGroup);
        CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);
        String oldCron = trigger.getCronExpression();
        if(!oldCron.equals(cron)){
            CronTrigger cronTrigger = TriggerBuilder.newTrigger().withIdentity(taskCode, jobGroup)
                    .withSchedule(CronScheduleBuilder.cronSchedule(cron)).build();
            Date date = scheduler.rescheduleJob(triggerKey, cronTrigger);
            if(date == null){
                throw new Exception("修改定时任务执行时间报错");
            }
        }
    }

    /**
     * 暂停某个定时任务（任务恢复后，暂停时间段内未执行的任务会继续执行，如暂停时间段内有2次，则会执行2次）
     * @param taskCode
     * @param jobGroup
     * @throws Exception
     */
    public void pauseJob(String taskCode, String jobGroup) throws Exception{
        JobKey jobKey = new JobKey(taskCode, jobGroup);
        JobDetail jobDetail = scheduler.getJobDetail(jobKey);
        if(jobDetail == null){
            return;
        }
        scheduler.pauseJob(jobKey);
    }

    /**
     * 恢复某个定时任务
     * @param taskCode
     * @param jobGroup
     * @throws Exception
     */
    public void resumeJob(String taskCode, String jobGroup) throws Exception{
        JobKey jobKey = new JobKey(taskCode, jobGroup);
        JobDetail jobDetail = scheduler.getJobDetail(jobKey);
        if(jobDetail == null){
            return;
        }
        scheduler.resumeJob(jobKey);
    }

    /**
     * 删除某个定时任务
     * @param taskCode
     * @param jobGroup
     * @throws Exception
     */
    public void deleteJob(String taskCode, String jobGroup) throws Exception{
        JobKey jobKey = new JobKey(taskCode, jobGroup);
        JobDetail jobDetail = scheduler.getJobDetail(jobKey);
        if(jobDetail == null){
            return;
        }
        scheduler.deleteJob(jobKey);
    }
}

创建几个定时任务

package com.shengun.quartz.task;

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;

import java.util.Date;

public class DemoJob1 implements Job {
    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        String taskCode = jobExecutionContext.getJobDetail().getKey().getName();
        System.out.println("定时任务1"+taskCode + new Date());
    }
}

在这里插入图片描述

数据库中的数据

在这里插入图片描述

运行结果

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

wqww_1
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
SpringBoot实现定时任务的三种方式
m0_67401761的博客
08-02 1万+
解释一下这个里面的含义，首先task这个就是你要定时的一个任务，delay代表延迟多久执行，我们这里为了测试设置为0就就是不延迟，period就是每个多久执行一次，我们为了看到效果设置为2000，也就是2秒执行一次。在上面代码块中有我对这部分有对应的解释。其实在springboot中，已经为我们提供了一个完成定时任务的技术。好了这个时候我们利用javaAPI做的一个定时任务就是完成了，其实这个就是基于java多线程去做的。但是现在在我们企业级应用中定时任务的应用非常广泛，于是就出现了完成定时任务的技术。..
Springboot 整合 Quartz（定时任务框架）
原名：@程序员大禹
01-31 2184
Quartz是 OpenSymphony 开源组织在 Job scheduling 领域又一个开源项目，完全由 Java 开发，可以用来执行定时任务，类似于 java.util.Timer。持久性作业 - 就是保持调度定时的状态;作业管理 - 对调度作业进行有效的管理;
Springboot--整合定时任务quartz--集群篇
拽着尾巴的鱼儿的博客
02-23 1892
通常在生产环境中，不会存在单体的应用，如一个订单服务，可能同时部署多个相同的服务到不同的服务上，从而形成集群。此时定时任务就会面临重复执行的问题；@Autowired@Bean// 标识quartz 数据源quartz 的集群需要同一个服务的不同实例，都要连接到同一个 定时任务的数据源，并且通过 org.quartz.jobStore.isClustered: true 开启 集群，以实现定时任务的负载均衡和故障转移。
SpringBoot整合定时任务
最新发布
qh1112的博客
05-10 691
springboot整合定时任务的具体实现
SpringBoot 中实现定时任务的几种方式
m0_71777195的博客
05-24 6032
这种方式很简单，主要就是先@EnableScheduling开启定时任务功能，然后在相应的方法上添加@Scheduled()中间写上相应的cron表达式即可。示例如下：schedule.ScheduleTask: Cron表达式参数参考：建议：直接在线生成Cron表达式比较方便：www.matools.com/cron/@Scheduled：除了支持灵活的参数表达式cron之外，还支持 fixedDelay，fixedRate，initialDelay 这些延时性的操作。启动测试就实现了基本的定时任务功
SpringBoot整合Quartz任务定时调度
06-08
SpringBoot整合Quartz任务定时调度，可以参考我的博客进行学习https://blog.csdn.net/sujin_/article/details/80615823
SpringBoot整合SpringTask实现定时任务
08-19
主要介绍了SpringBoot整合SpringTask实现定时任务,需要的朋友可以参考下
Springboot整合Quartz实现定时任务数据库动态配置
03-17
Springboot整合Quartz实现定时任务数据库动态配置，新增任务、修改cron表达式、暂停任务、恢复任务、删除任务等操作
springboot整合quartz定时任务yml文件配置方式
03-23
spring-cloud-alibaba+dubbo+nacos+quartz以yml配置方式实现
springboot整合quartz实现定时任务示例
08-30
总结来说，SpringBoot整合Quartz提供了更强大的定时任务管理能力，能够处理复杂的调度需求，如按照特定日期、时间间隔或者Cron表达式来执行任务。而SpringBoot自身的定时任务API则适用于一些简单场景，以注解驱动的...
maven工程-基于springboot定时任务
07-21
基于springboot的定时任务实现
SpringBoot 整合Quartz（集群）实现定时任务调度
02-14
1、若是部署多台机器，到了时间点，只有一台会执行，其他不会执行。 2、若多个节点其中一个scheduler执行job失败，将会被另外一个scheduler执行
【SpringBoot整合系列】SpringBoot整合定时任务【Quartz】
低调做人，低调编码，神码都是浮云
04-01 1537
SpringBoot整合定时任务
Spring Boot 整合定时任务，可以动态编辑的定时任务
江南一点雨的专栏
03-09 4520
定时任务，松哥之前写过多篇文章和大家介绍，上次还自己 DIY 了一个可以动态编辑的定时任务，还录了一个配套视频： 相关的资料链接戳这里： Spring 定时任务玩出花！ 手把手教你定制可编辑的定时任务！ 开发可配置的定时任务～第二弹 Vue非典型用法，一个简单的管理页面 不过我们当时自己写的这个不支持分布式环境，想要支持倒也不是啥难事，弄一个 zookeeper 或者 redis 作为公共的信息中心，里边记录了定时任务的各种运行情况，有了这个就能支持分布式环境了。 今天咱们不自己写了，我们来看一个现成
spring boot 集成定时任务
u010825190的博客
04-25 476
版本说明 Spring Boot 版本：2.6.1 添加web依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> 在启动类上添加注解开启任务支持 @SpringBootApplication @EnableSchedulin
springboot集成定时任务
cv大师
05-07 342
springboot集成定时任务 两种方法 一种是使用 Spring 自带的定时任务处理器 @Scheduled 注解，另一种就是使用第三方框架 Quartz ，Spring Boot 源自 Spring+SpringMVC ，因此天然具备这两个 Spring 中的定时任务实现策略，当然也支持 Quartz。 一：实现@Scheduled 注解 Scheduled 注解实现比较简单 分为两种方式 1.静态执行 支持灵活的参数表达式cron之外，还支持简单的延时操作，例如 fixedDelay ，fixedR
SpringBoot整合Quartz实现定时任务
qq_29305715的博客
03-16 7825
1、Quartz简介 Quartz是OpenSymphony开源组织在Job scheduling领域又一个开源项目，它可以与J2EE与J2SE应用程序相结合也可以单独使用。Quartz可以用来创建简单或为运行十个，百个，甚至是好几万个Jobs这样复杂的程序。Jobs可以做成标准的Java组件或 EJBs。 1.1 Quartz的三大核心组件 调度器：Scheduler。 任务：JobDetail。 触发器：Trigger，包括 SimpleTrigger 和 CronTrigger。 （1）Job（
Spring boot定时任务及集成Quartz
热门推荐
骆超
09-21 1万+
各种企业应用几乎都会用到任务调度的需求，比如论坛每天凌晨统计用户的 积分，每隔半个小时生成精华文章… Spring boot中使用定时任务 Spring boot中使用定时任务只要使用两个注解@EnableScheduling、@Scheduled 在Spring boot的启动类上添加@EnableScheduling注解，开启基于注解的定时任务 @MapperScan(basePackage...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值