springBoot动态整合Quartz

最新推荐文章于 2023-10-19 14:17:31 发布
最新推荐文章于 2023-10-19 14:17:31 发布
阅读量856 收藏 3
点赞数
分类专栏： 猿码优创 技术 文章标签： 动态Quartz 七子表达式 Quartz java整合Quartz
本文为猿码优创原创文章，猿码优创博客地址：https://cnbuilder.cn 未经猿码优创允许不得转载。
本文链接：https://blog.csdn.net/weixin_39984161/article/details/105638209
版权

动态Quart定时任务 项目目录：

file

Sql文件：


创建表：

CREATE TABLE `sys_task` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `name` varchar(50) NOT NULL COMMENT '任务名',
  `content` varchar(50) DEFAULT NULL COMMENT '任务描述',
  `cron_expression` varchar(30) NOT NULL COMMENT '七子表达式',
  `class_method` varchar(200) NOT NULL COMMENT '任务执行时调用哪个类的方法 包名+类名',
  `state` varchar(1) NOT NULL COMMENT '任务状态 0：未启动 1：启动',
  `job_group` varchar(20) NOT NULL COMMENT '分组+名字会生成一个job任务 两者+相加不能重复！！！',
  `create_time` datetime DEFAULT NULL COMMENT '创建时间',
  `update_time` datetime DEFAULT NULL COMMENT '更新时间',
  PRIMARY KEY (`id`)
) ENGINE=MyISAM AUTO_INCREMENT=36 DEFAULT CHARSET=utf8;

插入测试数据：
INSERT INTO `cnbuilder`.`sys_task` ( `id`, `name`, `content`, `cron_expression`, `class_method`, `state`, `job_group`, `create_time`, `update_time` )
VALUES
	( 1, 'helloword', '测试', '0/10 * * * * ?', 'cn.cnbuilder.trendsquartz.task.HelloWorldJob', '0', 'TEST_GROUP', '2018-06-29 23:31:42', '2018-06-29 23:31:42' );

java代码


config：
package cn.cnbuilder.trendsquartz.config;


import cn.cnbuilder.trendsquartz.factory.JobFactory;
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.scheduling.quartz.SchedulerFactoryBean;

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

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;

@Configuration
public class QuartzConfig {

    @Autowired
    private JobFactory jobFactory;

    @Bean
    public SchedulerFactoryBean schedulerFactoryBean() {
        SchedulerFactoryBean schedulerFactoryBean = new SchedulerFactoryBean();
        try {
            //覆盖原来的任务
            schedulerFactoryBean.setOverwriteExistingJobs(true);
            //容器工厂
            schedulerFactoryBean.setJobFactory(jobFactory);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return schedulerFactoryBean;
    }

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



JobFactory:

package cn.cnbuilder.trendsquartz.factory;

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
public class JobFactory extends AdaptableJobFactory {
    //这个对象Spring会帮我们自动注入进来,也属于Spring技术范畴.
    //为什么需要这个类呢，在我写的这个demo中，大家可以将此类删掉，发现程序也可以政策运营，可是我为什么还是加上呢。
    //大家可以看下我们的任务类，大家可以看到Job对象的实例化过程是在Quartz中进行的，这时候我们将spring的东西注入进来，肯定是行不通的，所以需要这个类
    @Autowired
    private AutowireCapableBeanFactory capableBeanFactory;

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



ScheduleJobInitListener:

package cn.cnbuilder.trendsquartz.listenner;


 import cn.cnbuilder.trendsquartz.service.ScheduleJobService;
 import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

@Component
@Order(value = 1)
public class ScheduleJobInitListener implements CommandLineRunner {

    @Autowired
    ScheduleJobService scheduleJobService;

    @Override
    public void run(String... arg0) throws Exception {
        try {
            //初始化
            scheduleJobService.initSchedule();
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

}



ScheduleJobService:

package cn.cnbuilder.trendsquartz.service;


import org.quartz.SchedulerException;

import java.util.List;


/**
 * 初始化定时任务工作
 */
public interface ScheduleJobService {
    void initSchedule() throws SchedulerException;
}

ScheduleJobServiceImpl:
package cn.cnbuilder.trendsquartz.service.impl;

import cn.cnbuilder.trendsquartz.enums.JobStatusEnum;
import cn.cnbuilder.trendsquartz.mapper.JobsMapper;
import cn.cnbuilder.trendsquartz.service.ScheduleJobService;
import cn.cnbuilder.trendsquartz.utils.QuartzManager;
import org.quartz.SchedulerException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.Map;

@Service
public class ScheduleJobServiceImpl implements ScheduleJobService {
    @Autowired
    private JobsMapper jobsMapper;

    @Autowired
    QuartzManager quartzManager;

    @Override
    public void initSchedule() throws SchedulerException {
        // 这里获取任务信息数据
        List<Map> jobList = jobsMapper.list();
        for (Map map : jobList) {
            if (JobStatusEnum.RUNNING.getCode().equals(map.get("state"))) {
                quartzManager.addJob(map);
            }
        }
    }
}


JobsController:
package cn.cnbuilder.trendsquartz.controller;


import cn.cnbuilder.trendsquartz.enums.JobStatusEnum;


import cn.cnbuilder.trendsquartz.service.JobsService;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;

import java.util.List;
import java.util.Map;

/**
 * quartz 控制层
 */
@Controller
@RequestMapping("/job")
public class JobsController {
    @Autowired
    private JobsService jobsService;


    @ResponseBody
    @PostMapping("/slectAll")
    public List<Map> slectAll() {
        // 查询列表数据
        List<Map> result = jobsService.list();
        return result;
    }


    @PostMapping("/edit")
    @ResponseBody
    public String edit(
            String name,
            String content,
            String cron_expression,
            String class_method,
            String job_group,
            Long id
    ) {
        Map job = jobsService.get(id);
        if (JobStatusEnum.RUNNING.getCode().equals(job.get("state"))) {
            return "修改之前请先停止任务！";
        }
        jobsService.updateJob(name, content, cron_expression, class_method, job_group, id, job.get("state").toString());

        return "success";
    }


    @PostMapping("/changeStatus/{id}")
    @ResponseBody
    public String changeStatus(@PathVariable("id") Long id, Boolean jobStatus) {
        String status = jobStatus == true ? JobStatusEnum.RUNNING.getCode() : JobStatusEnum.STOP.getCode();
        try {
            jobsService.changeStatus(id, status);
            return "success";
        } catch (Exception e) {
            e.printStackTrace();
        }
        return "任务状态修改失败";
    }

    /**
     * 删除
     */
    @PostMapping("/remove/{id}")
    @ResponseBody
    public String remove(@PathVariable("id") Long id) {
        Map taskServer = jobsService.get(id);
        if (JobStatusEnum.RUNNING.getCode().equals(taskServer.get("state").toString())) {
            return "删除前请先停止任务！";

        }
        if (jobsService.remove(id) > 0) {
            return "success";
        }
        return "删除任务失败！ ";
    }

    /**
     * 批量删除
     */
    @PostMapping("/removeBatch")
    @ResponseBody
    public String removeBatch(@RequestParam("ids[]") Long[] ids) {
        for (Long id : ids) {
            Map taskServer = jobsService.get(id);
            if (JobStatusEnum.RUNNING.getCode().equals(taskServer.get("state").toString())) {
                return "删除前请先停止任务！";
            }
        }
        jobsService.removeBatch(ids);
        return "success";
    }

    /**
     * 新增保存
     */
    @ResponseBody
    @PostMapping("/save")
    public String save(
            String name,
            String content,
            String cron_expression,
            String class_method,
            String job_group
    ) {
        if (jobsService.save(name, content, cron_expression, class_method, job_group) > 0) {
            return "success";
        }
        return "新增任务失败！";
    }


}


jobService:

package cn.cnbuilder.trendsquartz.service;

import org.quartz.SchedulerException;

import java.util.List;
import java.util.Map;


/**
 * JobsService
 */
public interface JobsService {

    Map get(Long id);

    List<Map> list();

    int save(String name, String content, String cron_expression, String class_method, String group);

    int updateJob(String name, String content, String cron_expression, String class_method, String job_group, Long id, String state);

    int remove(Long id);

    int removeBatch(Long[] ids);


    void changeStatus(Long jobId, String jobStatus) throws SchedulerException;

    void updateCron(Long jobId) throws SchedulerException;

}


JobsServiceImpl:
package cn.cnbuilder.trendsquartz.service.impl;

import cn.cnbuilder.trendsquartz.enums.JobStatusEnum;
import cn.cnbuilder.trendsquartz.mapper.JobsMapper;

import cn.cnbuilder.trendsquartz.service.JobsService;
import cn.cnbuilder.trendsquartz.utils.QuartzManager;
import org.quartz.SchedulerException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;


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

@Service
public class JobsServiceImpl implements JobsService {
    @Autowired
    private JobsMapper jobsMapper;

    @Autowired
    QuartzManager quartzManager;

    @Override
    public Map get(Long id) {
        return jobsMapper.get(id);
    }

    @Override
    public List<Map> list() {
        List<Map> list = jobsMapper.list();
        return list;
    }

    @Override
    public int save(String name, String content, String cron_expression, String class_method, String job_group) {

        //进行封装包装
        HashMap<String, Object> job = new HashMap<>();
        job.put("name", name);
        job.put("content", content);
        job.put("cron_expression", cron_expression);
        job.put("class_method", class_method);
        job.put("job_group", job_group);
        job.put("create_time", new Date());
        job.put("update_time", new Date());
        //默认关闭定时任务
        job.put("state", 0);
        return jobsMapper.save(job);
    }

    @Override
    public int updateJob(String name, String content, String cron_expression, String class_method, String job_group, Long id, String state) {
        HashMap<String, Object> job = new HashMap<>();
        job.put("name", name);
        job.put("content", content);
        job.put("cron_expression", cron_expression);
        job.put("class_method", class_method);
        job.put("job_group", job_group);
        job.put("update_time", new Date());
        job.put("id", id);
        job.put("state", state);
        return jobsMapper.update(job);
    }

    @Override
    public int remove(Long id) {
        try {
            Map job = get(id);
            quartzManager.deleteJob(job);
            return jobsMapper.remove(id);
        } catch (SchedulerException e) {
            e.printStackTrace();
            return 0;
        }

    }

    @Override
    public int removeBatch(Long[] ids) {
        for (Long id : ids) {
            try {
                Map task = get(id);
                quartzManager.deleteJob(task);
            } catch (SchedulerException e) {
                e.printStackTrace();
                return 0;
            }
        }
        return jobsMapper.removeBatch(ids);
    }


    @Override
    public void changeStatus(Long jobId, String jobStatus) throws SchedulerException {
        Map job = get(jobId);
        if (job == null) {
            return;
        }
        if (JobStatusEnum.STOP.getCode().equals(jobStatus)) {
            //暂停job
            quartzManager.deleteJob(job);
            job.put("state", 0);
        } else {
            job.put("state", 1);
            //直接启动
            quartzManager.addJob(job);
        }
        updateJob(job.get("name").toString(), job.get("content").toString(), job.get("cron_expression").toString(), job.get("class_method").toString(), job.get("job_group").toString(), jobId, job.get("state").toString());

    }

    @Override
    public void updateCron(Long jobId) throws SchedulerException {
        Map job = get(jobId);
        if (job == null) {
            return;
        }
        if (JobStatusEnum.RUNNING.getCode().equals(job.get("state").toString())) {
            quartzManager.updateJobCron(job);
        }
        updateJob(job.get("name").toString(), job.get("content").toString(), job.get("cron_expression").toString(), job.get("class_method").toString(), job.get("job_group").toString(), jobId, job.get("state").toString());
    }
}


JobsMapper:

package cn.cnbuilder.trendsquartz.mapper;


import org.apache.ibatis.annotations.Mapper;


import java.util.List;
import java.util.Map;

@Mapper
public interface JobsMapper {
    Map get(Long id);

    List<Map> list();

    int save(Map job);

    int update(Map task);

    int remove(Long id);

    int removeBatch(Long[] ids);
}


QuartzMapper.xml:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="cn.cnbuilder.trendsquartz.mapper.JobsMapper">

	<select id="get" parameterType="java.lang.Long" resultType="map">
		select
	      id, name, content, cron_expression, class_method, state,
        job_group, create_time, update_time
		from sys_task
		where id = #{id,jdbcType=BIGINT}
	</select>
	<select id="list" resultType="map">
		select
	      id, name, content, cron_expression, class_method, state,
        job_group, create_time, update_time
		from sys_task
		order by id asc
	</select>

	<insert id="save" parameterType="map">
        insert into sys_task (id, name, content, cron_expression, class_method, state,
        job_group, create_time, update_time)
        values (#{id,jdbcType=BIGINT}, #{name,jdbcType=VARCHAR},
        #{content,jdbcType=VARCHAR},
        #{cron_expression,jdbcType=VARCHAR}, #{class_method,jdbcType=VARCHAR}, #{state,jdbcType=VARCHAR},
        #{job_group,jdbcType=VARCHAR},
        #{create_time,jdbcType=TIMESTAMP},
        #{update_time,jdbcType=TIMESTAMP})
    </insert>

	<update id="update" parameterType="map">
		update sys_task
		<set>
			<if test="name != null">
				name = #{name,jdbcType=VARCHAR},
			</if>
			<if test="content != null">
				content = #{content,jdbcType=VARCHAR},
			</if>
			<if test="cronExpression != null">
				cron_expression = #{cron_expression,jdbcType=VARCHAR},
			</if>
			<if test="class_method != null">
				class_method = #{class_method,jdbcType=VARCHAR},
			</if>
			<if test="state != null">
				state = #{state,jdbcType=VARCHAR},
			</if>
			<if test="job_group != null">
				job_group = #{job_group,jdbcType=VARCHAR},
			</if>

			<if test="createTime != null">
				create_time = #{create_time,jdbcType=TIMESTAMP},
			</if>

			<if test="updateTime != null">
				update_time = #{update_time,jdbcType=TIMESTAMP},
			</if>
		</set>
		where id = #{id,jdbcType=BIGINT}
	</update>

	<delete id="remove">
        delete from sys_task where id = #{id,jdbcType=BIGINT}
    </delete>

	<delete id="removeBatch">
		delete from sys_task where id in
		<foreach item="id" collection="array" open="(" separator=","
				 close=")">
			#{id}
		</foreach>
	</delete>

</mapper>



application.yml:

spring:
  profiles:
    active: dev #选择要用那个配置文件
	
application-dev.yml:

#项目端口号访问路径
server:
  port: 12001
  servlet:
    context-path: /

#spring
spring:
  # mysql 配置
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    type: com.zaxxer.hikari.HikariDataSource
    url: jdbc:mysql://127.0.0.1/cnbuilder?useUnicode=true&characterEncoding=UTF-8
    username: root
    password: root

#mybatis
mybatis-plus:
  mapper-locations: classpath:/mapper/*Mapper.xml
  
  #实体扫描，多个package用逗号或者分号分隔
  typeAliasesPackage: cn.cnbuilder.trendsquartz.entity
  global-config:
    # 数据库相关配置
    db-config:
      #主键类型  AUTO:"数据库ID自增", INPUT:"用户输入ID",ID_WORKER:"全局唯一ID (数字类型唯一ID)", UUID:"全局唯一ID UUID";
      id-type: id_worker
      #字段策略 IGNORED:"忽略判断",NOT_NULL:"非 NULL 判断"),NOT_EMPTY:"非空判断"
      field-strategy: not_empty
      #驼峰下划线转换
      column-underline: true
      #数据库大写下划线转换
#      capital-mode: true
      #逻辑删除配置
      logic-delete-value: 0
      logic-not-delete-value: 1
    #刷新mapper 调试神器
    refresh: true
  # 原生配置
  configuration:
    map-underscore-to-camel-case: true
    cache-enabled: false
		

TrendsquartzApplication:

package cn.cnbuilder.trendsquartz;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

}


HelloWorldJob:

package cn.cnbuilder.trendsquartz.task;


import org.quartz.DisallowConcurrentExecution;
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.stereotype.Component;

import java.util.Date;

@DisallowConcurrentExecution //作业不并发
@Component
public class HelloWorldJob implements Job {
    @Override
    public void execute(JobExecutionContext arg0) throws JobExecutionException {
        System.out.println("欢迎使用定时任务 "+ new Date());
    }
}



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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.2.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>cn.cnbuilder</groupId>
    <artifactId>trendsquartz</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>trendsquartz</name>
    <description>SpringBoot动态quartzDemo</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>

        <!-- quartz -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-quartz</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.46</version>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.0.7.1</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

终、、本文就是Springboot整合动态Quartz，有什么问题可以联系我。

本文用到的代码下载链接: https://download.csdn.net/download/weixin_39984161/12109390

没有积分请移步：www.cnbuilder.cn

鼓励作者写出更好的技术文档，就请我喝一瓶哇哈哈哈哈哈哈哈。。你们的赞助决定我更新的速度哦！

微信：

支付宝：

感谢一路支持我的人。。。。。

Love me and hold me
QQ:69673804（16年老号）
EMAIL:itw@tom.com
友链交换
如果有兴趣和本博客交换友链的话，请按照下面的格式在评论区进行评论，我会尽快添加上你的链接。

网站名称：猿码优创
网站地址：http://blog.cnbuilder.cn
网站描述：年少是你未醒的梦话，风华是燃烬的彼岸花。
网站Logo/头像： [头像地址](https://blog.cnbuilder.cn/upload/2018/7/avatar20180720144536200.jpg)

欢迎关注猿码优创（联系小优优进内部群哦，新鲜技术优先更新）：

file

猿码优创
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
springboot2.0整合quartz
12-27
本篇文章将详细探讨如何在Spring Boot 2.0项目中整合Quartz，以及这种方式的优势。 首先，让我们了解Spring Boot 2.0的特性。Spring Boot 2.0带来了许多改进，包括性能优化、对Java 9的支持、更新依赖项到最新版本...
Springboot Quartz定时任务的动态调度使用，实战详解
默默不代表沉默
06-30 5933
前言 用到过Quartz定时任务框架的，第一眼看到Quartz就肯定会想起，调度工厂JobFactory、触发器Trigger、任务实例Job。 那么该篇，就会结合实战案例来一步一步让大家都了解，怎么玩弄这个Quartz框架，能实现 所谓的动态调度。 内容： 1.随项目启动即运行的 定时任务 2.动态触发的定时任务 ，包括： 随时创建新的定时任务； 随时执行指定的某个定时任务； 随时暂停指定的某个定时任务； 随时重启指定的某个定时任务； 随时删除指定的某个定时任务； 随时查看指定的..
springboot整合quartz实现数据库动态配置
三水沁
02-08 2813
什么是Quzrtz？ Quartz是一个开源任务调度框架，可以根据用户设定的时间规则来执行作业。简单来说，用户可以提前设定时间，规定好该时间所需要做的任务，当到达设定时间时，该任务便会按照原先定好的流程运行。 运用场景 1.定时轮询数据库同步 2.定时邮件通知 3.定时在线考试 4.等等 Quartz核心组件 任务：JobDetail Job（任务）：是一个接口，可以通过实现该接口来定义需要执行的任务。 JobDetail是用来描述Job实现类以及相关静态信息，比如任务在scheduler中的任务名、组名等
SpringBoot使用Quartz
weixin_43816557的博客
12-03 5220
所谓"调度"就是制定好的什么时间做什么事情的计划我们使用过的最简单的调度方法就是Timer但是Timer的调度功能过于单一，只能是指定时间的延时调用和周期运行而Quartz可以更详细的指定时间，进行计划调用，是一个当今市面上流行的高效的任务调度管理工具所谓"调度"就是制定好的什么时间做什么事情的计划由OpenSymphony开源组织开发是java编写的,我们使用时需要导入依赖即可
springboot集成定时任务框架quartz
jacklife的博客
01-16 1311
springboot集成定时任务框架quartz quartz框架可以很方便的执行定时任务，任务可以持久化到数据库中，这里使用的数据库为postgres。 集成步骤： 1. quartz和数据库驱动maven依赖 &amp;lt;dependency&amp;gt; &amp;lt;groupId&amp;gt;org.quartz-scheduler&amp;lt;/groupId&amp;gt; ..
SpringBoot Quartz 动态定时任务
qq_22074337的博客
06-08 1965
SpringBoot Quartz 动态定时任务
Springboot2.0.1整合Quartz动态定时任务
09-15
本文将深入探讨如何在SpringBoot 2.0.1版本中整合Quartz，实现动态定时任务，并结合MyBatis-Plus进行数据操作。 首先，我们要在SpringBoot项目中引入Quartz和MyBatis-Plus的依赖。在`pom.xml`文件中，添加如下依赖...
Springboot整合动态Quartz.zip
01-17
SpringBoot整合动态Quartz是一个常见的任务调度解决方案，用于在Java应用程序中执行定时任务。Quartz是一个功能丰富的开源作业调度框架，而SpringBoot则提供了一种简单快捷的方式来构建独立的、生产级别的基于Java的...
springboot整合quartz完整项目
11-02
综上所述，SpringBoot整合Quartz的完整项目可以帮助开发者高效地构建定时任务系统，提供动态管理和监控功能，同时充分利用SpringBoot的简洁性和便利性。这个项目具有很高的实用价值，可作为模板进行二次开发和扩展。
Springboot2-Quartz 后台可动态配置的定时任务
02-28
在SpringBoot项目中整合Quartz，可以方便地管理这些定时任务。 在SpringBoot 2.x中集成Quartz，我们需要以下几个步骤： 1. 添加依赖：在项目的pom.xml或build.gradle文件中，引入Quartz Scheduler的相关依赖。...
springboot+quartz 动态化配置定时任务
07-25
springboot+quartz 动态化配置，可在页面操作，查看、添加、修改、删除，暂停等操作
spring boot 与quartz整合（一）
喜欢DNF的小黑猫的博客
04-01 202
springboot本身可以使用@EnableScheduling注解进行定时任务 沿用的springboot少xml配置的优良传统，本身支持表达式等多种定时任务 @Component //加入spring容器 @EnableScheduling //开启对定时任务的支持 public class Myjob { @Scheduled(cron = "*/5 * * * * ?")...
springboot之quartz动态可控定时任务
最新发布
qq_14926283的博客
10-19 829
Quartz是一个开源的任务调度框架，可以用来实现定时任务的调度，如定时发送邮件、定时备份数据等。Quartz具有很高的可靠性和灵活性，支持集群部署和分布式调度，并且提供了丰富的API和插件，可以轻松实现复杂的调度需求。Quartz的工作原理是通过Job和Trigger两个核心概念来实现的，Job是具体需要执行的任务，Trigger用来触发任务的执行时机。在Quartz中，可以通过定义各种Trigger来实现不同的调度策略，如简单调度、Cron调度等。
Spring Boot整合Quartz实现动态配置
m0_71777195的博客
07-20 1815
注：添加任务接口仍然需要开发者提前准备好任务类，接口的目的是实现定时任务的动态调整，按需进行开关和修改，请注意这点。
SpringBoot搭配Quartz实现动态定时任务
wl_Honest的博客
12-27 2378
前面2篇文章讲述了如何实现简单的定时任务，不过由于执行周期是写在配置文件里的，如果想要修改周期或者暂停任务都是比较麻烦的事情，那么能不能在不修改代码和暂停服务的情况下动态修改定时任务周期或者手动暂停任务？ 通过Quartz是可以实现这一目标的，本文参考了GitHub上的文章，写了个动态定时任务的demo，特此记录。 参考链接：https://github.com/xkcoding/spring-boot-demo/tree/master/demo-task-quartz 首先引入需要的jar包：
SpringBoot集成Quartz实现动态定时任务
微微~
05-19 2149
一、Quartz 简介 Quartz 是 OpenSymphony 开源组织在 Job Scheduling 领域又一个开源项目，是完全由 Java 开发的一个开源任务日程管理系统，“任务进度管理器”就是一个在预先确定（被纳入日程）的时间到达时，负责执行（或者通知）其他软件组件的系统。 Quartz 是一个开源的作业调度框架，它完全由 Java 写成，并设计用于 J2SE 和 J2EE 应用中，它提供了巨大的灵活性而不牺牲简单性 当定时任务愈加复杂时，使用 Spring 注解 @Schedule 已经不能满
springboot整合Quartz实现动态配置定时任务
热门推荐
牛奋lch
03-09 11万+
前言 在我们日常的开发中，很多时候，定时任务都不是写死的，而是写到数据库中，从而实现定时任务的动态配置，下面就通过一个简单的示例，来实现这个功能。 一、新建一个springboot工程，并添加依赖 org.springframework.boot spring-boot-starter-data-jpa com.h2database h2 run
简单方便的实现spring boot 动态管理定时任务
搬砖磊的博客
08-29 575
添加依赖 <!--quartz相关依赖--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-quartz</artifactId> </dependency> 2. 创建定时任务实体类 pac
SpringBoot整合Quartz之动态控制任务(暂停，启动，修改执行时间)
临窗，听雨声
01-16 1万+
SpringBoot整合 Quartz 篇请移步https://blog.csdn.net/yali_aini/article/details/85287074 此篇文章讲述如何动态控制Quartz 定时任务。 其实很简单，就是使用自带的 Scheduler 类。 上配置类： /** * 配置类 */ @Configuration public class QuartzCon...
SpringBoot整合Quartz
10-19
SpringBoot整合Quartz可以通过两种方式实现定时任务的调度。第一种是使用SpringBoot内置的简单注解方式，这种方式适用于简单的定时任务场景。第二种是使用Quartz，Quartz是Java体系中最完善的定时方案，适用于更复杂...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值