springboot整合Quartz实现动态配置定时任务

最新推荐文章于 2023-07-22 08:00:00 发布
最新推荐文章于 2023-07-22 08:00:00 发布
阅读量3k 收藏
点赞数
分类专栏： spring boot Quartz

前言

在我们日常的开发中，很多时候，定时任务都不是写死的，而是写到数据库中，从而实现定时任务的动态配置，下面就通过一个简单的示例，来实现这个功能。

一、新建一个springboot工程，并添加依赖

[html] view plain copy print ?
  1. <dependency>  
  2.             <groupId>org.springframework.boot</groupId>  
  3.             <artifactId>spring-boot-starter-data-jpa</artifactId>  
  4.         </dependency>  
  5.   
  6.         <dependency><!-- 为了方便测试，此处使用了内存数据库 -->  
  7.             <groupId>com.h2database</groupId>  
  8.             <artifactId>h2</artifactId>  
  9.             <scope>runtime</scope>  
  10.         </dependency>  
  11.         <dependency>  
  12.             <groupId>org.springframework.boot</groupId>  
  13.             <artifactId>spring-boot-starter-test</artifactId>  
  14.             <scope>test</scope>  
  15.         </dependency>  
  16.           
  17.         <dependency>  
  18.             <groupId>org.quartz-scheduler</groupId>  
  19.             <artifactId>quartz</artifactId>  
  20.             <version>2.2.1</version>  
  21.             <exclusions>  
  22.                 <exclusion>  
  23.                     <artifactId>slf4j-api</artifactId>  
  24.                     <groupId>org.slf4j</groupId>  
  25.                 </exclusion>  
  26.             </exclusions>  
  27.         </dependency>  
  28.         <dependency><!-- 该依赖必加，里面有sping对schedule的支持 -->  
  29.                        <groupId>org.springframework</groupId>  
  30.                        <artifactId>spring-context-support</artifactId>  
  31.         </dependency>  
<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-jpa</artifactId>
		</dependency>

		<dependency><!-- 为了方便测试，此处使用了内存数据库 -->
			<groupId>com.h2database</groupId>
			<artifactId>h2</artifactId>
			<scope>runtime</scope>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
		
		<dependency>
			<groupId>org.quartz-scheduler</groupId>
			<artifactId>quartz</artifactId>
			<version>2.2.1</version>
			<exclusions>
				<exclusion>
					<artifactId>slf4j-api</artifactId>
					<groupId>org.slf4j</groupId>
				</exclusion>
			</exclusions>
		</dependency>
		<dependency><!-- 该依赖必加，里面有sping对schedule的支持 -->
                       <groupId>org.springframework</groupId>
                       <artifactId>spring-context-support</artifactId>
        </dependency>
二、配置文件application.properties
[java] view plain copy print ?
  1. # 服务器端口号    
  2. server.port=7902  
  3. # 是否生成ddl语句    
  4. spring.jpa.generate-ddl=false    
  5. # 是否打印sql语句    
  6. spring.jpa.show-sql=true    
  7. # 自动生成ddl，由于指定了具体的ddl，此处设置为none    
  8. spring.jpa.hibernate.ddl-auto=none    
  9. # 使用H2数据库    
  10. spring.datasource.platform=h2    
  11. # 指定生成数据库的schema文件位置    
  12. spring.datasource.schema=classpath:schema.sql    
  13. # 指定插入数据库语句的脚本位置    
  14. spring.datasource.data=classpath:data.sql    
  15. # 配置日志打印信息    
  16. logging.level.root=INFO    
  17. logging.level.org.hibernate=INFO    
  18. logging.level.org.hibernate.type.descriptor.sql.BasicBinder=TRACE    
  19. logging.level.org.hibernate.type.descriptor.sql.BasicExtractor=TRACE    
  20. logging.level.com.itmuch=DEBUG   
# 服务器端口号  
server.port=7902
# 是否生成ddl语句  
spring.jpa.generate-ddl=false  
# 是否打印sql语句  
spring.jpa.show-sql=true  
# 自动生成ddl，由于指定了具体的ddl，此处设置为none  
spring.jpa.hibernate.ddl-auto=none  
# 使用H2数据库  
spring.datasource.platform=h2  
# 指定生成数据库的schema文件位置  
spring.datasource.schema=classpath:schema.sql  
# 指定插入数据库语句的脚本位置  
spring.datasource.data=classpath:data.sql  
# 配置日志打印信息  
logging.level.root=INFO  
logging.level.org.hibernate=INFO  
logging.level.org.hibernate.type.descriptor.sql.BasicBinder=TRACE  
logging.level.org.hibernate.type.descriptor.sql.BasicExtractor=TRACE  
logging.level.com.itmuch=DEBUG
三、Entity类
[java] view plain copy print ?
  1. package com.chhliu.springboot.quartz.entity;  
  2.   
  3. import javax.persistence.Column;  
  4. import javax.persistence.Entity;  
  5. import javax.persistence.GeneratedValue;  
  6. import javax.persistence.GenerationType;  
  7. import javax.persistence.Id;  
  8.   
  9. @Entity  
  10. public class Config {  
  11.     @Id  
  12.       @GeneratedValue(strategy = GenerationType.AUTO)  
  13.       private Long id;  
  14.   
  15.       @Column  
  16.       private String cron;  
  17.   
  18.     /** 
  19.      * @return the id 
  20.      */  
  21.     public Long getId() {  
  22.         return id;  
  23.     }  
  24.         ……此处省略getter和setter方法……  
  25. }  
package com.chhliu.springboot.quartz.entity;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class Config {
	@Id
	  @GeneratedValue(strategy = GenerationType.AUTO)
	  private Long id;

	  @Column
	  private String cron;

	/**
	 * @return the id
	 */
	public Long getId() {
		return id;
	}
        ……此处省略getter和setter方法……
}
四、任务类
[java] view plain copy print ?
  1. package com.chhliu.springboot.quartz.entity;  
  2.   
  3. import org.slf4j.Logger;  
  4. import org.slf4j.LoggerFactory;  
  5. import org.springframework.context.annotation.Configuration;  
  6. import org.springframework.scheduling.annotation.EnableScheduling;  
  7. import org.springframework.stereotype.Component;  
  8.   
  9. @Configuration  
  10. @Component // 此注解必加  
  11. @EnableScheduling // 此注解必加  
  12. public class ScheduleTask {  
  13.     private static final Logger LOGGER =  LoggerFactory.getLogger(ScheduleTask.class);  
  14.     public void sayHello(){  
  15.         LOGGER.info("Hello world, i'm the king of the world!!!");  
  16.     }  
  17. }  
package com.chhliu.springboot.quartz.entity;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.stereotype.Component;

@Configuration
@Component // 此注解必加
@EnableScheduling // 此注解必加
public class ScheduleTask {
	private static final Logger LOGGER =  LoggerFactory.getLogger(ScheduleTask.class);
	public void sayHello(){
		LOGGER.info("Hello world, i'm the king of the world!!!");
	}
}
五、Quartz配置类

由于springboot追求零xml配置，所以下面会以配置Bean的方式来实现

[java] view plain copy print ?
  1. package com.chhliu.springboot.quartz.entity;  
  2.   
  3. import org.quartz.Trigger;  
  4. import org.springframework.context.annotation.Bean;  
  5. import org.springframework.context.annotation.Configuration;  
  6. import org.springframework.scheduling.quartz.CronTriggerFactoryBean;  
  7. import org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean;  
  8. import org.springframework.scheduling.quartz.SchedulerFactoryBean;  
  9.   
  10. @Configuration  
  11. public class QuartzConfigration {  
  12.     /** 
  13.      * attention: 
  14.      * Details：配置定时任务 
  15.      */  
  16.     @Bean(name = "jobDetail")  
  17.     public MethodInvokingJobDetailFactoryBean detailFactoryBean(ScheduleTask task) {// ScheduleTask为需要执行的任务  
  18.         MethodInvokingJobDetailFactoryBean jobDetail = new MethodInvokingJobDetailFactoryBean();  
  19.         /* 
  20.          *  是否并发执行 
  21.          *  例如每5s执行一次任务，但是当前任务还没有执行完，就已经过了5s了， 
  22.          *  如果此处为true，则下一个任务会执行，如果此处为false，则下一个任务会等待上一个任务执行完后，再开始执行 
  23.          */  
  24.         jobDetail.setConcurrent(false);  
  25.           
  26.         jobDetail.setName("srd-chhliu");// 设置任务的名字  
  27.         jobDetail.setGroup("srd");// 设置任务的分组，这些属性都可以存储在数据库中，在多任务的时候使用  
  28.           
  29.         /* 
  30.          * 为需要执行的实体类对应的对象 
  31.          */  
  32.         jobDetail.setTargetObject(task);  
  33.           
  34.         /* 
  35.          * sayHello为需要执行的方法 
  36.          * 通过这几个配置，告诉JobDetailFactoryBean我们需要执行定时执行ScheduleTask类中的sayHello方法 
  37.          */  
  38.         jobDetail.setTargetMethod("sayHello");  
  39.         return jobDetail;  
  40.     }  
  41.       
  42.     /** 
  43.      * attention: 
  44.      * Details：配置定时任务的触发器，也就是什么时候触发执行定时任务 
  45.      */  
  46.     @Bean(name = "jobTrigger")  
  47.     public CronTriggerFactoryBean cronJobTrigger(MethodInvokingJobDetailFactoryBean jobDetail) {  
  48.         CronTriggerFactoryBean tigger = new CronTriggerFactoryBean();  
  49.         tigger.setJobDetail(jobDetail.getObject());  
  50.         tigger.setCronExpression("0 30 20 * * ?");// 初始时的cron表达式  
  51.         tigger.setName("srd-chhliu");// trigger的name  
  52.         return tigger;  
  53.   
  54.     }  
  55.   
  56.     /** 
  57.      * attention: 
  58.      * Details：定义quartz调度工厂 
  59.      */  
  60.     @Bean(name = "scheduler")  
  61.     public SchedulerFactoryBean schedulerFactory(Trigger cronJobTrigger) {  
  62.         SchedulerFactoryBean bean = new SchedulerFactoryBean();  
  63.         // 用于quartz集群,QuartzScheduler 启动时更新己存在的Job  
  64.         bean.setOverwriteExistingJobs(true);  
  65.         // 延时启动，应用启动1秒后  
  66.         bean.setStartupDelay(1);  
  67.         // 注册触发器  
  68.         bean.setTriggers(cronJobTrigger);  
  69.         return bean;  
  70.     }  
  71. }  
package com.chhliu.springboot.quartz.entity;

import org.quartz.Trigger;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.quartz.CronTriggerFactoryBean;
import org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;

@Configuration
public class QuartzConfigration {
    /**
     * attention:
     * Details：配置定时任务
     */
    @Bean(name = "jobDetail")
    public MethodInvokingJobDetailFactoryBean detailFactoryBean(ScheduleTask task) {// ScheduleTask为需要执行的任务
        MethodInvokingJobDetailFactoryBean jobDetail = new MethodInvokingJobDetailFactoryBean();
        /*
         *  是否并发执行
         *  例如每5s执行一次任务，但是当前任务还没有执行完，就已经过了5s了，
         *  如果此处为true，则下一个任务会执行，如果此处为false，则下一个任务会等待上一个任务执行完后，再开始执行
         */
        jobDetail.setConcurrent(false);
        
        jobDetail.setName("srd-chhliu");// 设置任务的名字
        jobDetail.setGroup("srd");// 设置任务的分组，这些属性都可以存储在数据库中，在多任务的时候使用
        
        /*
         * 为需要执行的实体类对应的对象
         */
        jobDetail.setTargetObject(task);
        
        /*
         * sayHello为需要执行的方法
         * 通过这几个配置，告诉JobDetailFactoryBean我们需要执行定时执行ScheduleTask类中的sayHello方法
         */
        jobDetail.setTargetMethod("sayHello");
        return jobDetail;
    }
    
    /**
     * attention:
     * Details：配置定时任务的触发器，也就是什么时候触发执行定时任务
     */
    @Bean(name = "jobTrigger")
    public CronTriggerFactoryBean cronJobTrigger(MethodInvokingJobDetailFactoryBean jobDetail) {
        CronTriggerFactoryBean tigger = new CronTriggerFactoryBean();
        tigger.setJobDetail(jobDetail.getObject());
        tigger.setCronExpression("0 30 20 * * ?");// 初始时的cron表达式
        tigger.setName("srd-chhliu");// trigger的name
        return tigger;

    }

    /**
     * attention:
     * Details：定义quartz调度工厂
     */
    @Bean(name = "scheduler")
    public SchedulerFactoryBean schedulerFactory(Trigger cronJobTrigger) {
        SchedulerFactoryBean bean = new SchedulerFactoryBean();
        // 用于quartz集群,QuartzScheduler 启动时更新己存在的Job
        bean.setOverwriteExistingJobs(true);
        // 延时启动，应用启动1秒后
        bean.setStartupDelay(1);
        // 注册触发器
        bean.setTriggers(cronJobTrigger);
        return bean;
    }
}
六、定时查库，并更新任务
[java] view plain copy print ?
  1. package com.chhliu.springboot.quartz.entity;  
  2.   
  3. import javax.annotation.Resource;  
  4.   
  5. import org.quartz.CronScheduleBuilder;  
  6. import org.quartz.CronTrigger;  
  7. import org.quartz.JobDetail;  
  8. import org.quartz.Scheduler;  
  9. import org.quartz.SchedulerException;  
  10. import org.springframework.beans.factory.annotation.Autowired;  
  11. import org.springframework.context.annotation.Configuration;  
  12. import org.springframework.scheduling.annotation.EnableScheduling;  
  13. import org.springframework.scheduling.annotation.Scheduled;  
  14. import org.springframework.stereotype.Component;  
  15.   
  16. import com.chhliu.springboot.quartz.repository.ConfigRepository;  
  17.   
  18. @Configuration  
  19. @EnableScheduling  
  20. @Component  
  21. public class ScheduleRefreshDatabase {  
  22.     @Autowired  
  23.     private ConfigRepository repository;  
  24.   
  25.     @Resource(name = "jobDetail")  
  26.     private JobDetail jobDetail;  
  27.   
  28.     @Resource(name = "jobTrigger")  
  29.     private CronTrigger cronTrigger;  
  30.   
  31.     @Resource(name = "scheduler")  
  32.     private Scheduler scheduler;  
  33.   
  34.     @Scheduled(fixedRate = 5000) // 每隔5s查库，并根据查询结果决定是否重新设置定时任务  
  35.     public void scheduleUpdateCronTrigger() throws SchedulerException {  
  36.         CronTrigger trigger = (CronTrigger) scheduler.getTrigger(cronTrigger.getKey());  
  37.         String currentCron = trigger.getCronExpression();// 当前Trigger使用的  
  38.         String searchCron = repository.findOne(1L).getCron();// 从数据库查询出来的  
  39.         System.out.println(currentCron);  
  40.         System.out.println(searchCron);  
  41.         if (currentCron.equals(searchCron)) {  
  42.             // 如果当前使用的cron表达式和从数据库中查询出来的cron表达式一致，则不刷新任务  
  43.         } else {  
  44.             // 表达式调度构建器  
  45.             CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(searchCron);  
  46.             // 按新的cronExpression表达式重新构建trigger  
  47.             trigger = (CronTrigger) scheduler.getTrigger(cronTrigger.getKey());  
  48.             trigger = trigger.getTriggerBuilder().withIdentity(cronTrigger.getKey())  
  49.                     .withSchedule(scheduleBuilder).build();  
  50.             // 按新的trigger重新设置job执行  
  51.             scheduler.rescheduleJob(cronTrigger.getKey(), trigger);  
  52.             currentCron = searchCron;  
  53.         }  
  54.     }  
  55. }  
package com.chhliu.springboot.quartz.entity;

import javax.annotation.Resource;

import org.quartz.CronScheduleBuilder;
import org.quartz.CronTrigger;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

import com.chhliu.springboot.quartz.repository.ConfigRepository;

@Configuration
@EnableScheduling
@Component
public class ScheduleRefreshDatabase {
	@Autowired
	private ConfigRepository repository;

	@Resource(name = "jobDetail")
	private JobDetail jobDetail;

	@Resource(name = "jobTrigger")
	private CronTrigger cronTrigger;

	@Resource(name = "scheduler")
	private Scheduler scheduler;

	@Scheduled(fixedRate = 5000) // 每隔5s查库，并根据查询结果决定是否重新设置定时任务
	public void scheduleUpdateCronTrigger() throws SchedulerException {
		CronTrigger trigger = (CronTrigger) scheduler.getTrigger(cronTrigger.getKey());
		String currentCron = trigger.getCronExpression();// 当前Trigger使用的
		String searchCron = repository.findOne(1L).getCron();// 从数据库查询出来的
		System.out.println(currentCron);
		System.out.println(searchCron);
		if (currentCron.equals(searchCron)) {
			// 如果当前使用的cron表达式和从数据库中查询出来的cron表达式一致，则不刷新任务
		} else {
			// 表达式调度构建器
			CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(searchCron);
			// 按新的cronExpression表达式重新构建trigger
			trigger = (CronTrigger) scheduler.getTrigger(cronTrigger.getKey());
			trigger = trigger.getTriggerBuilder().withIdentity(cronTrigger.getKey())
					.withSchedule(scheduleBuilder).build();
			// 按新的trigger重新设置job执行
			scheduler.rescheduleJob(cronTrigger.getKey(), trigger);
			currentCron = searchCron;
		}
	}
}
六、相关脚本

1、data.sql

[sql] view plain copy print ?
  1. insert into config(id,cron) values(1,'0 0/2 * * * ?'); # 每2分钟执行一次定时任务  
insert into config(id,cron) values(1,'0 0/2 * * * ?'); # 每2分钟执行一次定时任务
2、schema.sql
[sql] view plain copy print ?
  1. drop table config if exists;  
  2. create table config(  
  3.     id bigint generated by default as identity,  
  4.     cron varchar(40),  
  5.     primary key(id)  
  6. );  
drop table config if exists;
create table config(
	id bigint generated by default as identity,
	cron varchar(40),
	primary key(id)
);
六、运行测试

测试结果如下：(Quartz默认的线程池大小为10)

[java] view plain copy print ?
  1. 0 30 20 * * ?  
  2. 0 0/2 * * * ?  
  3. 2017-03-08 18:02:00.025  INFO 5328 --- [eduler_Worker-1] c.c.s.quartz.entity.ScheduleTask         : Hello world, i'm the king of the world!!!  
  4. 2017-03-08 18:04:00.003  INFO 5328 --- [eduler_Worker-2] c.c.s.quartz.entity.ScheduleTask         : Hello world, i'm the king of the world!!!  
  5. 2017-03-08 18:06:00.002  INFO 5328 --- [eduler_Worker-3] c.c.s.quartz.entity.ScheduleTask         : Hello world, i'm the king of the world!!!  
  6. 2017-03-08 18:08:00.002  INFO 5328 --- [eduler_Worker-4] c.c.s.quartz.entity.ScheduleTask         : Hello world, i'm the king of the world!!!  
0 30 20 * * ?
0 0/2 * * * ?
2017-03-08 18:02:00.025  INFO 5328 --- [eduler_Worker-1] c.c.s.quartz.entity.ScheduleTask         : Hello world, i'm the king of the world!!!
2017-03-08 18:04:00.003  INFO 5328 --- [eduler_Worker-2] c.c.s.quartz.entity.ScheduleTask         : Hello world, i'm the king of the world!!!
2017-03-08 18:06:00.002  INFO 5328 --- [eduler_Worker-3] c.c.s.quartz.entity.ScheduleTask         : Hello world, i'm the king of the world!!!
2017-03-08 18:08:00.002  INFO 5328 --- [eduler_Worker-4] c.c.s.quartz.entity.ScheduleTask         : Hello world, i'm the king of the world!!!
从上面的日志打印时间来看，我们实现了动态配置，最初的时候，任务是每天20:30执行，后面通过动态刷新变成了每隔2分钟执行一次。

虽然上面的解决方案没有使用Quartz推荐的方式完美，但基本上可以满足我们的需求，当然也可以采用触发事件的方式来实现，例如当前端修改定时任务的触发时间时，异步的向后台发送通知，后台收到通知后，然后再更新程序，也可以实现动态的定时任务刷新

子非鱼yy
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
面试官：Spring Boot 中如何实现定时任务？| 教你通过3种方式实现Spring Boot定时任务
小小鱼儿小小林的博客
03-13 148
实现定时任务除了可以通过使用 Spring 的 @Scheduled 注解来实现，还有下面这些方式也可以实现定时任务
springboot整合quartz实现后台可控的定时任务
01-11
springboot整合quartz实现后台可控的定时任务： 前端实现采用layui 后端采用springboot，mybatisplus，mysql，quartz技术实现 可以单独使用，也可以集成到其他项目中。 是一套定时任务通用开发模板
springboot整合Quartz实现动态配置定时任务的方法
08-29
本篇文章主要介绍了springboot整合Quartz实现动态配置定时任务的方法，非常具有实用价值，需要的朋友可以参考下
SpringBoot 整合Quartz（集群）实现定时任务调度
02-14
1、若是部署多台机器，到了时间点，只有一台会执行，其他不会执行。 2、若多个节点其中一个scheduler执行job失败，将会被另外一个scheduler执行
springboot整合Quartz实现动态配置定时任务源码
06-10
springboot整合Quartz实现动态配置定时任务源码
Springboot整合Quartz实现定时任务数据库动态配置
03-17
Springboot整合Quartz实现定时任务数据库动态配置，新增任务、修改cron表达式、暂停任务、恢复任务、删除任务等操作
spring boot 定时任务的实现以及cron定时表达式
热门推荐
健康平安的活着的专栏
07-23 2万+
一.cron表达式 1.cron表达式的格式：秒-分-时-日-月-星期-年（几乎不用，忽略） 如果是6位，则格式为：秒-分-时-日-月-星期 2. 部分表达术语的解释： 1.“*”字符代表所有可能的值，例如：“*”在子表达式（月）里表示每个月的含义，“*”在子表达式（天（星期））表示星期的每一天 2.有些子表达式能包含一些范围或列表，例如：子表达式（天（星期））可以为 “MON-FRI”，“MON，WED，FRI”，“MON-WED,SAT” 3.“/”字符用来指定数值的增量，在子表达式（分
k8s+springboot+CronJob 定时任务部署
xiaogg3678的专栏
07-11 972
k8s+springboot+CronJob 定时任务部署
Spring定时任务（附带：Cron表达式从配置文件读取）
最新发布
宋冠巡的博客
07-22 915
Spring定时任务（附带：Cron表达式从配置文件读取）
任务调度（1）-Spring @Scheduled详解
springmonster的博客
01-20 898
Spring3.0版本之后提供了@EnableScheduling和@Scheduled来进行定时任务的功能。 使用Spring创建定时任务非常简单，我们可以使用如下两种方式（当然不仅仅只包括这两种）： 基于注解（@Scheduled） 基于接口（SchedulingConfigurer），这里可以自定义线程池的线程数和动态设置定时任务的属性 1. 基于注解的实现如下： 首先在Spring启动类添加注解@EnableScheduling @SpringBootApplication @EnableSch
解决quartz 定时任务报错问题
JUNY_JAVA的博客
01-16 8987
定时任务运行提示： java.lang.ClassCastException: bdhj.modules.job.entity.ScheduleJobEntity cannot be cast to bdhj.modules.job.entity.ScheduleJobEntity at bdhj.modules.job.utils.ScheduleJob.executeInterna...
SpringBoot官方支持任务调度框架，轻量级用起来也挺香！
macrozheng的专栏
10-19 6076
之前我们讲过一个分布式任务调度框架PowerJob，可以通过可视化的方式来进行任务调度。但是有时候我们只是需要一个轻量级的任务调度功能，而PowerJob需要搭建调度中心未免有些重，这时...
Java连接hdfs （参数配置一）
陈大奔的专栏
05-03 2930
今天在Java访问hdfs上文件的时候，报错：2018-05-03 22:40:53.343 INFO 10158 --- [eduler_Worker-4] org.apache.hadoop.ipc.Client : Retrying connect to server: master/172.16.80.70:8020. Already tried 37 time(s
Spring调度任务cronjob 精确指定任务的运行时间
JAVA 像一把利剑刺向我的心脏！
11-13 7889
我们在调度一个工作的时候,如果设置每隔多长时间运行一次，使用的是SimpleTriggerBean，它的配置如下： 这里我们设置了每隔15分钟(1分钟是60000)执行一次我们创建的工作。SimpleTriggerBean只能让我们指定工作执行的频率，不能让我们指定工作执行的具体时间。比方说，我们要求在每天的晚上10点执行某个具体的工作，那么Simp
k8s cronjob部署springboot 分布式任务
xiaogg3678的专栏
05-23 198
k8s cronjob部署springboot 分布式任务
springboot动态定时任务 + cron (附踩过的 cron表达式 那些坑)
weixin_45369440的博客
06-08 922
其实如果只是一个简单的动态定时任务，并不需要一堆乱七八糟的配置，本文用最简单的方法 /** * @author linnine */ @Configuration @Slf4j public class CompleteSchedule implements SchedulingConfigurer { @Resource ICronService cronService; @Override public void configureTasks(ScheduledT
Cron和Spring定时任务
09-06 135
1.Java Spring spring定时任务cronExpression的值（配置定时时间）格式说明： 一个cronExpression表达式有至少6个（也可能是7个）由空格分隔的时间元素。从左至右，这些元素的定义如下： 1．秒（0–59） 2．分钟（0–59） 3．小时（0–23） 4．月份中的日期（1–31） 5．月份（1–12或JAN–DEC）...
spring定时任务之cronJob
云端轻躺
08-21 558
情景： 数据库中的数据需要根据formula在一定时间上计算得到相应的结果数据，就是说，根据formula去计算，得到相应结果保存在相应字段上，这个job是定时触发的，计算按照一定的事件类型。 代码： [code="java"] public class DashboardDataCalculationJob { private final static Logger...
springboot整合quartz常见配置
04-04
1. 引入依赖 在 `pom.xml` 文件中引入以下依赖： ``` <groupId>org.springframework.boot <artifactId>spring-boot-starter-quartz ...以上是springboot整合quartz的常见配置，可以根据具体需求进行调整。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值