Spring boot 下使用Quartz

最新推荐文章于 2024-06-29 10:43:48 发布
最新推荐文章于 2024-06-29 10:43:48 发布
阅读量1.7k 收藏 3
点赞数
分类专栏： Spring boot 文章标签： quartz spring-boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yy756127197/article/details/74839577
版权

项目中需要定时执行某个任务，功能包括
启动，重新启动，暂停，恢复，更新，添加，删除，查询
这些功能是通用的哈，可以拿来用在任何项目中
1. pom.xml

<!-- quartz -->

        <dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz</artifactId>
            <version>2.2.3</version>
        </dependency>

2. 实体类
这里用到了lombok，方便管理实体类（下几篇文章中会讲解lombok，swagger2，通用Mapperde等使用方式。都是一些方便开发的小技术）

@EqualsAndHashCode(callSuper = false)
@Data
@NoArgsConstructor
@AllArgsConstructor
@Entity
@Table(name = "table_schedule_job")
public class ScheduleJobVo {
    @Id
    @Column(name = "Id")
    private String id = UUID.randomUUID().toString();

    /** 任务名称 */
    private String jobName;

    /** 任务类 */
    private String jobClass;

    /** 任务方法 */
    private String jobMethod;

    /** 任务状态 0禁用 1启用 2删除 */
    private String status;

    /** 任务运行时间表达式 */
    private String cronExpression;

    /** 任务描述 */
    private String description;

    /** 计划开始时间 */
    private Timestamp planStartDate;

    /** 计划结束时间 */
    private Timestamp planEndDate;

    @Transient
    private Integer page = 1;

    @Transient
    private Integer rows = 10;

    public ScheduleJobVo(String id, String status) {
        super();
        this.id = id;
        this.status = status;
    }

}

3. 工具类 SpringUtil.java
用于获得Spring管理的Bean

import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;

@Component
public class SpringUtil implements ApplicationContextAware {

    private static ApplicationContext applicationContext;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        if(SpringUtil.applicationContext == null) {
            SpringUtil.applicationContext = applicationContext;
        }

        System.out.println("---------------------------------------------------------------------");

        System.out.println("========ApplicationContext配置成功,在普通类可以通过调用SpringUtils.getAppContext()获取applicationContext对象,applicationContext="+SpringUtil.applicationContext+"========");

        System.out.println("---------------------------------------------------------------------");
    }

    //获取applicationContext
    public static ApplicationContext getApplicationContext() {
        return applicationContext;
    }

    //通过name获取 Bean.
    public static Object getBean(String name){
        return getApplicationContext().getBean(name);
    }

    //通过class获取Bean.
    public static <T> T getBean(Class<T> clazz){
        return getApplicationContext().getBean(clazz);
    }

    //通过name,以及Clazz返回指定的Bean
    public static <T> T getBean(String name,Class<T> clazz){
        return getApplicationContext().getBean(name, clazz);
    }

}

4. Service接口类 SchedulerService.java

public interface SchedulerService {

    /**
     * @Description: 创建任务调度
     * @param parms
     * @param name
     * @param group
     * @param cronExpression
     * @param c
     * @throws Exception
     */
    public void createScheduler(ScheduleJobVo job) throws SchedulerException;

    /**
     * @Description: 删除任务
     * @param name
     *            工作名称
     * @param group
     *            工作组
     * @throws SchedulerException
     * @throws ParseException
     */
    public boolean deleteJob(String name) throws SchedulerException;

    /**
     * @Description: 创建任务调度
     * @param parms
     *            工作参数
     * @param name
     *            工作名称
     * @param c
     *            类名称
     * @param minutes
     *            间隔执行时长(分钟),传参时,需把时间转换成分钟
     * @throws Exception
     */
    public void createSchedulerJob(Map<String, Object> parms, String name,
            Class<? extends Job> c, String cronExpression) throws Exception;

    /**
     * @Description: 暂停任务
     * @param name
     *            任务名称
     * @throws SchedulerException
     */
    public void pauseJob(String name) throws SchedulerException;

    /**
     * @Description:恢复任务
     * @param name
     *            任务名称
     * @throws SchedulerException
     */
    public void resumeJob(String name) throws SchedulerException;

    public void restartJob(ScheduleJobVo job) throws SchedulerException ;

}

5. Service实现类
一些调度器操作

@Service
@Slf4j
public class SchedulerServiceImpl implements SchedulerService {

    private static Scheduler scheduler;
    static {
        SchedulerFactory sf = new StdSchedulerFactory();
        try {
            scheduler = sf.getScheduler();
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }

    /**
     * @Description: 创建任务调度
     */
    public void createScheduler(ScheduleJobDto job) throws SchedulerException {
        TriggerKey triggerKey = TriggerKey.triggerKey(job.getJobName());
        CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);
        if (trigger == null) {
            JobDetail jobDetail = JobBuilder.newJob(QuartzJobFactory.class)
                    .withIdentity(job.getJobName()).build();
            jobDetail.getJobDataMap().put("scheduleJob", job);
            // 表达式调度构建器
            CronScheduleBuilder scheduleBuilder = CronScheduleBuilder
                    .cronSchedule(job.getCronExpression());
            scheduleBuilder.withMisfireHandlingInstructionDoNothing();
            // 按新的cronExpression表达式构建一个新的trigger
            try {
                TriggerBuilder<CronTrigger> triggerBuilder = TriggerBuilder
                        .newTrigger().withIdentity(triggerKey)
                        .withSchedule(scheduleBuilder);
                if (job.getPlanStartDate() != null) {
                    triggerBuilder.startAt(DateUtil.timestampToDate(job.getPlanStartDate()));
                } else {
                    triggerBuilder.startNow();
                }
                if (job.getPlanEndDate() != null) {
                    triggerBuilder.endAt(DateUtil.timestampToDate(job.getPlanEndDate()));
                }

                trigger = triggerBuilder.build();
            } catch (Exception e1) {
                e1.printStackTrace();
            }
            try {
                scheduler.scheduleJob(jobDetail, trigger);
                if (!scheduler.isShutdown()) {
                    scheduler.start();
                }
            } catch (SchedulerException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * @Description: 删除任务
     * @param name
     *            JOB名称
     */
    public boolean deleteJob(String name) throws SchedulerException {
        TriggerKey triggerKey = new TriggerKey(name);
        Trigger trigger = scheduler.getTrigger(triggerKey);
        if (trigger != null) {
            JobKey jobKey = JobKey.jobKey(name);
            scheduler.pauseTrigger(triggerKey);// 停止触发器
            scheduler.unscheduleJob(triggerKey);// 移除触发器
            return scheduler.deleteJob(jobKey);// 移除当前进程的Job
        }
        return false;
    }

    /**
     * @Description: 创建任务调度
     * @param parms
     *            工作参数
     * @param name
     *            工作名称
     * @param c
     *            类名称
     * @param minutes
     *            间隔执行时长(分钟),传参时,需把时间转换成分钟
     * @throws Exception
     */
    public void createSchedulerJob(Map<String, Object> parms, String name,
            Class<? extends Job> c, String cronExpression) throws Exception {
        JobDetail job = JobBuilder.newJob(c).withIdentity(name).build();
        if (parms != null && !parms.isEmpty()) {
            JobDataMap dataMap = job.getJobDataMap();
            dataMap.putAll(parms);
        }
        CronScheduleBuilder builder = CronScheduleBuilder
                .cronSchedule(cronExpression);
        Trigger trigger = TriggerBuilder.newTrigger().withIdentity(name)
                .withSchedule(builder).build();
        scheduler.scheduleJob(job, trigger);
        scheduler.start();
        scheduler.isStarted();
    }

    /**
     * @Description: 暂停任务
     * @param name
     *            任务名称
     * @throws SchedulerException
     */
    public void pauseJob(String name) throws SchedulerException {
        JobKey jobKey = JobKey.jobKey(name);
        scheduler.pauseJob(jobKey);
        //需要补偿的话就注释掉触发器（后两句）
        //如果注释掉，当暂停一段时间后，再启动就会把暂停期间的任务全部执行一次
        TriggerKey triggerKey = TriggerKey.triggerKey(name);
        scheduler.pauseTrigger(triggerKey);
    }

    /**
     * @Description:恢复任务
     * @param name
     *            任务名称
     * @throws SchedulerException
     */
    public void resumeJob(String name) throws SchedulerException {
        JobKey jobKey = JobKey.jobKey(name);
        scheduler.resumeJob(jobKey);
        //需要补偿的话就注释掉触发器（后两句）
        //如果注释掉，当暂停一段时间后，再启动就会把暂停期间的任务全部执行一次
        TriggerKey triggerKey = TriggerKey.triggerKey(name);
        scheduler.resumeTrigger(triggerKey);
    }

    @Override
    public void restartJob(ScheduleJobVo job) throws SchedulerException {
        try {
            TriggerKey triggerKey = TriggerKey.triggerKey(job.getJobName());
            //获取trigger，即在spring配置文件中定义的 bean id="myTrigger"
            CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);
            //表达式调度构建器
            CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(job.getCronExpression());
            //修改按照新的执行策略执行，不允许修改立即执行一次
            scheduleBuilder.withMisfireHandlingInstructionDoNothing();
            //按新的cronExpression表达式重新构建trigger
            trigger = trigger.getTriggerBuilder().withIdentity(triggerKey)
                    .withSchedule(scheduleBuilder).build();
            //按新的trigger重新设置job执行
            scheduler.rescheduleJob(triggerKey, trigger);
        } catch (SchedulerException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

6. Job工厂
用来得到某个JOB

public class QuartzJobFactory implements Job {

    @Override
    public void execute(JobExecutionContext context)
            throws JobExecutionException {
        try {
            ScheduleJobVo scheduleJob = (ScheduleJobVo) context
                    .getMergedJobDataMap().get("scheduleJob");
            Object task = SpringUtil.getBean(scheduleJob.getJobClass());
            Class<?> demo = task.getClass();//得到类
            Method method = demo.getMethod(scheduleJob.getJobMethod());//得到方法
            method.invoke(task);//执行方法
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

7. Controler 控制类
以上有调度的Service方法，业务的Service自己写吧，就不贴出来了（对于ScheduleJobVo增删改查而已）

@Slf4j
@RestController
@RequestMapping("/quartz")
@Api(value = "/", description = "调度相关接口")
public class QuartzController {

    @Autowired
    private SchedulerService schedulerService;
    @Autowired
    private IScheduleJobService scheduleJobService;//ScheduleJobVo的Service实现类（你们自己去实现）
    //存储Job的id用
    private List<String> ids = new ArrayList<String>();

    @ResponseBody
    @PostConstruct
    //  被@PostConstruct修饰的方法会在服务器加载Servle的时候运行，并且只会被服务器执行一次。PostConstruct在构造函数之后执行,init()方法之前执行。  
    public void initJob() {
        List<ScheduleJobVo> list = scheduleJobService.findEnableScheduleJob();//得到所有任务
        for (ScheduleJobVo scheduleJob : list) {
            if ((scheduleJob.getStatus().trim()).equals("1")) {//1:表示任务处于启动状态
                try {
                    log.info("调度启动开始=============================");
                    schedulerService.createScheduler(scheduleJob);
                    log.info("调度启动结束=============================");
                } catch (Exception e) {
                    e.printStackTrace();
                }
            } else {
                ids.add(scheduleJob.getId());//删除的时候用
            }

        }
    }

    @RequestMapping(value = "/startJob", method = RequestMethod.GET)
    @ResponseBody
    @ApiOperation(notes = "/startJob", httpMethod = "GET", value = "启动trigger")
    public Response startJob(@RequestParam String id) {
        ScheduleJobVo job = scheduleJobService.findScheduleJob(id);
        if(job == null){
            return Response.failure("任务不存在");
        }
        try {
            schedulerService.createScheduler(job);
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
        return new Response(Response.STATUS_OK,"启动成功");
        //Response是我自己实现的类，你们改成自己的返回值就好了。
    }

    @RequestMapping(value = "/restartJob", method = RequestMethod.GET)
    @ResponseBody
    //@ApiOperation 是swagger中的注解，不需要的可以删掉（后续会有专门讲解）
    @ApiOperation(notes = "/restartJob", httpMethod = "GET", value = "重新启动trigger")
    public Response restartJob(@RequestParam String id) {
        ScheduleJobVo job = scheduleJobService.findScheduleJob(id);
        if(job == null){
            return Response.failure("任务不存在");
        }
        try {
            schedulerService.restartJob(job);
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
        return new Response(Response.STATUS_OK,"重新启动成功");
    }

    @RequestMapping(value = "/pauseJob/{id}", method = RequestMethod.PATCH)
    @ResponseBody
    @ApiOperation(notes = "/pauseJob/{id}", httpMethod = "PATCH", value = "暂停JOB")
    public Response pauseJob(@PathVariable String id) {
        ScheduleJobVo job = scheduleJobService.findScheduleJob(id);
        if(job == null){
            return Response.failure("任务不存在");
        }
        try {
            schedulerService.pauseJob(job.getJobName());
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
        //更新数据库中任务状态
        Response response = scheduleJobService
                .updateScheduleJob(new ScheduleJobVo(id, "0"));

        return response;
    }

    @RequestMapping(value = "/resumeJob/{id}", method = RequestMethod.PATCH)
    @ResponseBody
    @ApiOperation(notes = "/resumeJob/{id}", httpMethod = "PATCH", value = "恢复JOB")
    public Response resumeJob(@PathVariable String id) {
        ScheduleJobVo job = scheduleJobService.findScheduleJob(id);
        if(job == null){
            return Response.failure("任务不存在");
        }
        try {
            schedulerService.resumeJob(job.getJobName());
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
        //更新数据库中任务状态
        Response response = scheduleJobService
                .updateScheduleJob(new ScheduleJobVo(id, "1"));

        return response;
    }

    @RequestMapping(value = "/updateJob", method = RequestMethod.PUT)
    @ResponseBody
    @ApiOperation(notes = "/updateJob", httpMethod = "PUT", value = "更新JOB")
    public Response updateJob(@RequestBody ScheduleJobVo job) {
        Response response = scheduleJobService.updateScheduleJob(job);
        return response;
    }

    @RequestMapping(value = "/insertJob", method = RequestMethod.POST)
    @ResponseBody
    @ApiOperation(notes = "/insertJob", httpMethod = "POST", value = "添加JOB")
    public Response insertJob(@RequestBody ScheduleJobVo job) {
        Response response = scheduleJobService.insertScheduleJob(job);
        return response;
    }

    @RequestMapping(value = "/deleteJob/{id}", method = RequestMethod.DELETE)
    @ResponseBody
    @ApiOperation(notes = "/deleteJob/{id}", httpMethod = "DELETE", value = "删除JOB")
    public Response deleteJob(@PathVariable String id) {
        ScheduleJobVo job = scheduleJobService.findScheduleJob(id);
        if(job == null){
            return Response.failure("任务不存在");
        }
        if (!ids.contains(id)) {//如果任务在启动列表中
            try {
                schedulerService.deleteJob(job.getJobName());
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        //更新数据库任务状态
        Response response = scheduleJobService
                .updateScheduleJob(new ScheduleJobVo(id, "2"));

        return response;
    }

    @RequestMapping(value = "/findJobs", method = RequestMethod.POST)
    @ResponseBody
    @ApiOperation(notes = "/findJobs", httpMethod = "POST", value = "查询JOB")
    public Response findJobs(@RequestBody ScheduleJobVo job) {
        List<ScheduleJobVo> list = scheduleJobService.findJobs(job);

        return Response.success(new PageInfo<ScheduleJobVo>(list));
    }
}

8. 自己的JOB
就是@Component注解的简单类，例如：

@Component
public class DispatchJob {
    public void dispatch() {
        system.out.println("=====拯救世界的程序员=====");   
    }

}

9. 数据表
这里写图片描述

好了，到这里调度器已经完成，自己在控制台跑着玩玩吧^^

更新日志：2017-07-11 增加计划开始时间，计划结束时间
更新日志：2017-07-25 增加多实例解决方案QUARTZ多实例解决方案

司马缸砸缸了
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
Springboot Quartz定时任务的动态调度使用，实战详解(1)
2401_84153262的博客
05-04 878
《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》，点击传送门，即可获取！*/@Beanpublic Properties quartzProperties() throws IOException{PropertiesFactoryBean propertiesFactoryBean = new PropertiesFactoryBean();//若不做额外配置,会有默认的配置文件加载 在jar org.quartz里面 有一份quartz.properties//propert
SpringBoot使用Quartz
weixin_43816557的博客
12-03 5275
所谓"调度"就是制定好的什么时间做什么事情的计划我们使用过的最简单的调度方法就是Timer但是Timer的调度功能过于单一，只能是指定时间的延时调用和周期运行而Quartz可以更详细的指定时间，进行计划调用，是一个当今市面上流行的高效的任务调度管理工具所谓"调度"就是制定好的什么时间做什么事情的计划由OpenSymphony开源组织开发是java编写的,我们使用时需要导入依赖即可
SpringBoot整合Quartz任务，java对任务创建、删除、修改、查询
张刚的博客
01-28 856
SpringBoot整合Quartz任务，java对任务创建、删除、修改、查询， java对Quartz任务创建，删除，修改，查询
SpringBoot整合Quartz实现动态定时任务
最新发布
这河里吗l的博客
06-29 1743
Quartz是一个开源的任务调度服务，它可以独立使用，也可与其它的Java EE，Java SE应用整合使用。无论是执行十个，一百个工作的简单任务，还是执行成百上千个工作的复杂调度任务都可以使用Quartz来实现，此外，Quartz还提供了很多企业级应用的特色，如JTA事务支持及集群。如果你的应用中有任务需要在特定的时间执行，亦或周期循环执行，则Quartz也许是你理想的选择。
spring-boot-quartz
08-29
spring-boot-quartz定时任务
springboot项目中Quartz
PaoShan的博客
03-08 3309
从介绍到用例测试，包含依赖等。。。
springBoot + Quartz
weixin_40461030的博客
05-01 4625
1. Quartz 概述 Quartz 是 OpenSymphony 开源组织在任务调度领域的一个开源项目，完全基于 Java 实现。该项目于 2009 年被 Terracotta 收购，目前是 Terracotta 旗下的一个项目。读者可以到下载Quartz 的发布版本及其源代码。 2. Quartz特点 作为一个优秀的开源调度框架，Quartz 具有以下特点： 强大的调度功能，例如支持丰富多样的调度方法，可以满足各种常规及特殊需求； 灵活的应用方式，例如支持任务和调度的多种组合方式，支持调度数
quartz在springboot中的使用
qq_17303159的博客
03-17 728
依赖 <!--添加web支持 --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> <version>2.1.1.RELEASE</version&
spring-boot使用quartz框架定时发送邮件
03-28
至此，我们就完成了在Spring Boot中使用Quartz框架定时发送邮件并生成报表的任务。这个过程中，我们利用Quartz的Cron表达式来定义任务的执行时间，通过Spring的邮件服务发送邮件，以及通过自定义的业务服务（如`...
spring-boot-quartz.zip
05-12
为了更灵活地管理和监控Quartz作业，可以使用Spring Boot Actuator提供的健康检查端点，或者集成Quartz的Web管理界面。此外，还可以通过Spring事件监听机制，在作业开始和结束时触发自定义逻辑。 总的来说，Spring ...
基于Spring Boot和Quartz的CRUD任务管理系统设计源码
04-17
本项目是基于Spring Boot和Quartz开发的CRUD任务管理系统设计源码，主要使用Java进行开发。项目共包含1637个文件，其中SVG矢量图文件760个，PNG图片文件640个，CSS样式文件56个，JavaScript源代码文件25个，SQL文件...
springboot-quartz
03-17
springboot-quartz项目，下载了就可以快速集成，这是博客地址：https://blog.csdn.net/persistencegoing/article/details/88393039
springboot中使用quartz
09-12
springboot中使用quartz，包括持久化和非持久化操作 解决service注入问题 介入指定job中传入参数问题
springboot2.0整合quartz
12-27
springboot2.0整合quartz，采用 spring-boot-starter-quartz方式，更为简单方式
spring-boot-Quartz-1.zip
10-12
本案例实现的功能是SpringBoot整合Quartz定时任务框架，实现在项目运行过程中自动执行工作任务，设定时间是每20秒执行一次。
spring boot + quartz 动态管理 分布式
08-29
在“Spring Boot + Quartz 动态管理 分布式”的场景下，Spring Boot被用来构建一个基础的、易于扩展的应用框架。 Quartz是Java平台上的开源作业调度框架，可以安排和执行周期性任务。它支持按日期、时间间隔、CRON...
SpringBoot-Quartz
梓鸿
04-09 250
一、新建一个springboot工程，并添加依赖 <?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" ...
spring boot集成quartz
m0_72167535的博客
11-17 2479
创建配置文件实现ApplicationRunner接口，实现run方法，在方法中，首先通过反射方式获取到要执行定时任务的类来创建jobdetail，然后根据执行规则创建执行的触发器trigger，再将jobdetail和trigger放到scheduler容器中，按照规则进行任务的执行。定时任务的全路径名称，执行的触发器以及任务名称，可以存放在数据库中，并在前端追加可视化画面来进行修改，删除及立即执行的功能。Quartz 中需要执行的任务详情，包括了任务的唯一标识和具体要执行的任务，可以通过。
spring boot 使用Quartz
05-14
在 Spring Boot 中使用 Quartz 非常简单，只需要按照以下步骤： 1. 添加依赖 在 pom.xml 文件中添加 Quartz 依赖： ```xml <groupId>org.quartz-scheduler <artifactId>quartz <version>2.3.2 ``` 2. 配置 ...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值