springboot-Quartz 集成源码分析和demo

最新推荐文章于 2024-09-14 18:17:39 发布
最新推荐文章于 2024-09-14 18:17:39 发布
阅读量2.2k 收藏 3
点赞数 1
分类专栏： spring Quartz 文章标签： quartz springboot-quartz
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/guo_xl/article/details/85068719
版权

springboot-Quartz 集成源码跟踪

在pom.xml里加入

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

利用starter的原理在
spring.factories里有

org.springframework.boot.autoconfigure.quartz.QuartzAutoConfiguration

则启动的时候就会加载QuartzAutoConfiguration，下面看下QuartzAutoConfiguration

@Configuration
@ConditionalOnClass({ Scheduler.class, SchedulerFactoryBean.class,
		PlatformTransactionManager.class })
		//加入QuartzProperties.class
@EnableConfigurationProperties(QuartzProperties.class)
@AutoConfigureAfter({ DataSourceAutoConfiguration.class,
		HibernateJpaAutoConfiguration.class })
public class QuartzAutoConfiguration {

private final QuartzProperties properties;

//构造器注入QuartzProperties
public QuartzAutoConfiguration(QuartzProperties properties,
			ObjectProvider<SchedulerFactoryBeanCustomizer> customizers,
			ObjectProvider<JobDetail[]> jobDetails,
			ObjectProvider<Map<String, Calendar>> calendars,
			ObjectProvider<Trigger[]> triggers, ApplicationContext applicationContext) {
		this.properties = properties;
		this.customizers = customizers;
		this.jobDetails = jobDetails.getIfAvailable();
		this.calendars = calendars.getIfAvailable();
		this.triggers = triggers.getIfAvailable();
		this.applicationContext = applicationContext;
	}
	
//定义一个SchedulerFactoryBean，前提是没有SchedulerFactoryBean	
@Bean
	@ConditionalOnMissingBean
	public SchedulerFactoryBean quartzScheduler() {
	//new 了一个SchedulerFactoryBean
		SchedulerFactoryBean schedulerFactoryBean = new SchedulerFactoryBean();
		SpringBeanJobFactory jobFactory = new SpringBeanJobFactory();
		jobFactory.setApplicationContext(this.applicationContext);
		schedulerFactoryBean.setJobFactory(jobFactory);
		
		//这里可以定义很多quartz.properteis里的属性
		if (this.properties.getSchedulerName() != null) {
			schedulerFactoryBean.setSchedulerName(this.properties.getSchedulerName());
		}
		schedulerFactoryBean.setAutoStartup(this.properties.isAutoStartup());
		schedulerFactoryBean
				.setStartupDelay((int) this.properties.getStartupDelay().getSeconds());
		schedulerFactoryBean.setWaitForJobsToCompleteOnShutdown(
				this.properties.isWaitForJobsToCompleteOnShutdown());
		schedulerFactoryBean
				.setOverwriteExistingJobs(this.properties.isOverwriteExistingJobs());
		if (!this.properties.getProperties().isEmpty()) {
			schedulerFactoryBean
					.setQuartzProperties(asProperties(this.properties.getProperties()));
		}
		if (this.jobDetails != null && this.jobDetails.length > 0) {
			schedulerFactoryBean.setJobDetails(this.jobDetails);
		}
		if (this.calendars != null && !this.calendars.isEmpty()) {
			schedulerFactoryBean.setCalendars(this.calendars);
		}
		if (this.triggers != null && this.triggers.length > 0) {
			schedulerFactoryBean.setTriggers(this.triggers);
		}
		customize(schedulerFactoryBean);
		return schedulerFactoryBean;
	}	
	
	
}

以下是SchedulerFactoryBean，可以看到是
implements FactoryBean，也就是这是Scheduler 这个定义的生成者

public class SchedulerFactoryBean extends SchedulerAccessor implements FactoryBean<Scheduler>,
		BeanNameAware, ApplicationContextAware, InitializingBean, DisposableBean, SmartLifecycle {
	//getObject() 是FactoryBean<Scheduler>的接口方法
	public Scheduler getObject() {
		return this.scheduler;
	}
}

FactoryBean和BeanFactory的区别，其实2者除了名字颠倒外，没有必然的关系。BeanFactory是个工厂类，顾名思义就是生产Bean的工厂。而FactoryBean是个生成BeanDefinition的类。

当代码里有这种@Autowired注入Scheduler的时候，如下

 @Autowired
 Scheduler scheduler;

BeanFactory会根据name为Scheduler来获取Scheduler,最终会通过SchedulerFactoryBean.getObject()来得到Scheduler。

通过分析得出FactoryBean.getObject()里得到的是this.scheduler.

public class SchedulerFactoryBean extends SchedulerAccessor implements FactoryBean<Scheduler>,
		BeanNameAware, ApplicationContextAware, InitializingBean, DisposableBean, SmartLifecycle {
	private Scheduler scheduler;
	public Scheduler getObject() {
			return this.scheduler;
		}
}

但这个Scheduler 在哪里被构造处理呢？

SchedulerFactoryBean implements InitializingBean,在InitializingBean里有afterPropertiesSet()

public class SchedulerFactoryBean extends SchedulerAccessor implements FactoryBean<Scheduler>,
		BeanNameAware, ApplicationContextAware, InitializingBean, DisposableBean, SmartLifecycle {
		
		public void afterPropertiesSet() throws Exception {
        ...
		// Initialize the Scheduler instance...
		//这里初始化了Scheduler
		this.scheduler = prepareScheduler(prepareSchedulerFactory());
		try {
			registerListeners();
			registerJobsAndTriggers();
		}
		catch (Exception ex) {
			...
		}
	}
	
}

bean 生命周期简单理解如下，注意InitializingBean#afterPropertiesSet()所处的位置

->construcor
->initialization(各种autowired)
->BeanPostProcessor#postProcessBeforeInitialization
->@postConsruct 或 InitializingBean#afterPropertiesSet() 或 @Bean(initMethod="xxx")
->BeanPostProcessor#postProcessAfterInitialization
->@PreDestroy

看prepareSchedulerFactory()方法，最后返回了SchedulerFactory，赋值给了SchedulerFactoryBean的scheduler

public class SchedulerFactoryBean{
    
	private Class<? extends SchedulerFactory> schedulerFactoryClass = 
	StdSchedulerFactory.class;
	
    private SchedulerFactory prepareSchedulerFactory() throws SchedulerException, IOException {
        	private SchedulerFactory schedulerFactory;
        //这里这个SchedulerFactory肯定为空，当然有办法可以让它不为空，通过定义SchedulerFactoryBeanCustomizer来实现   
		SchedulerFactory schedulerFactory = this.schedulerFactory;
		if (schedulerFactory == null) {
			// Create local SchedulerFactory instance (typically a StdSchedulerFactory)
			//这里也写了这里是实例化出StdSchedulerFactory
			schedulerFactory = BeanUtils.instantiateClass(this.schedulerFactoryClass);
			if (schedulerFactory instanceof StdSchedulerFactory) {
			//调用initSchedulerFactory来填充StdSchedulerFactory)
			//看过Quartz的官方demo，就知道StdSchedulerFactory用来生产出sheduler
			initSchedulerFactory((StdSchedulerFactory) schedulerFactory);
			}
			else if (this.configLocation != null || this.quartzProperties != null ||
					this.taskExecutor != null || this.dataSource != null) {
				throw new IllegalArgumentException(
						"StdSchedulerFactory required for applying Quartz properties: " + schedulerFactory);
			}
			// Otherwise, no local settings to be applied via StdSchedulerFactory.initialize(Properties)
		}
		// Otherwise, assume that externally provided factory has been initialized with appropriate settings
		return schedulerFactory;
	}
}

initSchedulerFactory主要是将配置信息配置到schedulerFactory里

private void initSchedulerFactory(StdSchedulerFactory schedulerFactory) throws SchedulerException, IOException {
		Properties mergedProps = new Properties();
        ...    
		CollectionUtils.mergePropertiesIntoMap(this.quartzProperties, mergedProps);
        ...
        //这里很重要，
        //可以直接通过 application.properties里的配置来配置quartz.properties里的配置spring.quartz.properties.xxx
		schedulerFactory.initialize(mergedProps);
	}

只所以看这里，是由于springboot的quartz整合官方文档实在是太过简单，只有寥寥数语

Quartz Scheduler configuration can be customized using spring.quartz properties and SchedulerFactoryBeanCustomizer beans, 
which allow programmatic SchedulerFactoryBean customization.
Advanced Quartz configuration properties can be customized using spring.quartz.properties.*.

翻译过来就是

Quartz Scheduler可以通过使用spring.quartz 的properties 和写SchedulerFactoryBeanCustomizer这个类来达到客户化SchedulerFactoryBean 的配置。更进一步的配置可以通过spring.quartz.properties.*

这样写连例子都没有，未免太过简略了。没有看源码根本不知道说的什么

prepareScheduler(prepareSchedulerFactory()) 在一些列的调用后会到StdSchedulerFactory的
private Scheduler instantiate()。这是个很长的方法
，但逻辑还算简单，各种初始化,下面只列出jobStore的配置

private Scheduler instantiate() throws SchedulerException {
  //cfg 就是上个代码片段里的mergedProps
        if (cfg == null) {
            initialize();
        }
        //jobstore,如果不配，默认是RAMJobStore
        //在application.properties里可以配置为
        //spring.quartz.properties.org.quartz.jobStore.class=org.quartz.impl.jdbcjobstore.JobStoreTX
           String jsClass = cfg.getStringProperty(PROP_JOB_STORE_CLASS,
                RAMJobStore.class.getName());
    
    try {
            js = (JobStore) loadHelper.loadClass(jsClass).newInstance();
        } catch (Exception e) {
            initException = new SchedulerException("JobStore class '" + jsClass
                    + "' could not be instantiated.", e);
            throw initException;
        }

        SchedulerDetailsSetter.setDetails(js, schedName, schedInstId);

    //这里可以获取到spring.quartz.properties.org.quartz.jobStore.xxx
    //xxx是jobStore这个类的里属性，比如isClustered，clusterCheckinInterval等
    //在applicaiton.properties配置成spring.quartz.properties.org.quartz.jobStore.isClustered = true
        tProps = cfg.getPropertyGroup(PROP_JOB_STORE_PREFIX, true, new String[] {PROP_JOB_STORE_LOCK_HANDLER_PREFIX});
        try {
            setBeanProps(js, tProps);
        } catch (Exception e) {
            initException = new SchedulerException("JobStore class '" + jsClass
                    + "' props could not be configured.", e);
            throw initException;
        }

        
        
}

因此我们要配置集群就可以在application.properties配置成如下：

spring.quartz.properties.org.quartz.jobStore.class=org.springframework.scheduling.quartz.LocalDataSourceJobStore
spring.quartz.properties.org.quartz.jobStore.isClustered = true
spring.quartz.properties.org.quartz.jobStore.clusterCheckinInterval = 10000
spring.quartz.properties.org.quartz.scheduler.instanceId = AUTO

Demo 1

这个例子主要是Quartz的简单应用。Quartz api 写的很人性化，只要看下方法名就知道什么意思，几乎不需要查文档。
需求 如下图需要能定制不同的执行计划
定期执行的选项

code
 public static void main(String[] args) throws SchedulerException {
        // Grab the Scheduler instance from the Factory
        Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
        // and start it off
        scheduler.start();

        // define the job and tie it to our MyJob class
        JobDetail job = newJob(MyJob.class)
                .withIdentity("job1", "group1")
                .build();

        //DAILY on12:00 START 【now】- END  【2019-3-1】
        GregorianCalendar calendar=new GregorianCalendar();
        calendar.set(2019,3,1);
        Date endTime=calendar.getTime();
        Trigger triggerDaily = newTrigger()
                .withIdentity("triggerDaily", "group1")
                .startNow()
                .endAt(endTime)
                .withSchedule(dailyAtHourAndMinute(12,0)).build();
         //DAILY exclude Sunday on 12:00 START 【now】- END  【2019-3-1】        
         Trigger triggerDaily2 = newTrigger()
                .withIdentity("triggerDaily2", "group1")
                .startNow()
                .endAt(endTime)
                .withSchedule(atHourAndMinuteOnGivenDaysOfWeek(12,0,2,3,4,5,6,7)).build();
        //WEELKY monday 12:00 START 【now】- END  【2019-3-1】
        Trigger triggerWeekly = newTrigger()
                .withIdentity("triggerWeekly", "group1")
                .startNow()
                .endAt(endTime)
                .withSchedule(weeklyOnDayAndHourAndMinute(DateBuilder.MONDAY,12,0)).build();
        //MONTHLY 31th 12:00 START 【now】- END  【2019-3-1】
        Trigger triggerMonthly = newTrigger()
                .withIdentity("triggerMonthly", "group1")
                .startNow()
                .endAt(endTime)
                .withSchedule(monthlyOnDayAndHourAndMinute(31,12,0)).build();

        // Tell quartz to schedule the job using our trigger
        //one job can only have one trigger
        //scheduler.scheduleJob(job, triggerDaily);
        //scheduler.scheduleJob(job, triggerDaily1);
        //scheduler.scheduleJob(job, triggerWeekly);
        scheduler.scheduleJob(job, triggerMonthly);
    }

Demo 2

需求：
  • 动态的增加，删除schedule任务。
  • 支持集群，只能集群里的一台机器执行。
  • 当其中一台机器宕机，其它机器要能继续执行。

通过springmvc来做这个例子。

执行sql

在maven lib里找到org.quartz-scheduler:quartz:2.3.0里的tables_mysql_innodb.sql

Code

application.properies

server.port=9999
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/ssmdb?serverTimezone=UTC
spring.datasource.username=root
spring.datasource.password=devuser
spring.datasource.driverClassName=com.mysql.cj.jdbc.Driver

spring.quartz.job-store-type=jdbc
#开启集群
spring.quartz.properties.org.quartz.jobStore.isClustered = true
spring.quartz.properties.org.quartz.jobStore.clusterCheckinInterval = 10000
spring.quartz.properties.org.quartz.scheduler.instanceId = AUTO

@SpringBootApplication
public class SchedualBootstrap {
    private Logger logger = LoggerFactory.getLogger(this.getClass());
    public static void main(String[] args) {
        SpringApplicationBuilder builder =new SpringApplicationBuilder(SchedualBootstrap.class);
        builder.run(args);
    }

   @Autowired
   Scheduler scheduler;
   
   //加入监听
   @PostConstruct
   public void init(){
            scheduler.getListenerManager().addSchedulerListener(new SchedulerListenerSupport(){
                @Override
                public void jobDeleted(JobKey jobKey) {
                    logger.info(jobKey.getName()+" is deleted");
                }
                public void jobAdded(JobDetail jobDetail) {
                    logger.info(jobDetail.getKey().getName()+" is add");
                }
                public void jobScheduled(Trigger trigger) {
                    logger.info(trigger.getJobKey()+" is trigger");
                }
            });
    }

public class JobBean {
    private String jobName;
    private int intervalSecond;
    //...setter and getter
}

rest 方式增加，减少schedual task

@RestController
public class schedualController {
    @Autowired
    Scheduler scheduler;

    @PostMapping("/schedual/add")
    public void addSchedual(@RequestBody JobBean jobBean){
        try {
            JobDetail jobDetail = newJob(MyJob.class)
                    .withIdentity(jobBean.getJobName(), "group1")
                    .usingJobData("jobName", jobBean.getJobName())
                    .storeDurably()
                    .build();
            scheduler.addJob(jobDetail,true);
            // Trigger the job to run now, and then repeat every 2 seconds
            Trigger trigger = newTrigger()
                    .withIdentity("trigger-"+jobBean.getJobName(), "group1")
                    .forJob(jobDetail)
                    .startNow()
                    .withSchedule(simpleSchedule()
                            .withIntervalInSeconds(jobBean.getIntervalSecond())
                            .repeatForever())
                    .build();

            scheduler.scheduleJob(trigger);
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }

    @PostMapping("/schedual/{key}/delete")
    public void deleteSchedual(@PathVariable String key){
        JobKey jobKey = new JobKey(key,"group1");
        try {
            if(scheduler.checkExists(jobKey)){
                scheduler.deleteJob(jobKey);
            }
        } catch (SchedulerException e) {
            e.printStackTrace();
        }

    }
}

job

@DisallowConcurrentExecution
public class MyJob implements org.quartz.Job{

    Logger logger = LoggerFactory.getLogger(this.getClass());

    private String JobName;

    public String getJobName() {
        return JobName;
    }

    public void setJobName(String jobName) {
        JobName = jobName;
    }

    public MyJob() {
    }

    public void execute(JobExecutionContext context) throws JobExecutionException {
        JobKey key = context.getJobDetail().getKey();
        logger.info(key.getName());
        logger.info(getJobName()+" : [Hello World!  MyJob is executing.]");
    }
}
How to run
  1. 修改application.properties server.port=9999 启动
  2. 修改application.properties server.port=9998 启动
  3. 打开postman,http://127.0.0.1:9998/schedual/add
    body
{
	"jobName":"job1",
	"intervalSecond":1
}

增加1个job1 ,每1秒运行一次

  1. 打开postman,http://127.0.0.1:9999/schedual/add
    body
{
	"jobName":"job2",
	"intervalSecond":3
}

增加1个job2 ,没3秒运行一次

看控制台输出,9998 运行job1,9999运行job2

5.关闭9999，会发现9998,运行job1和job2

github code

Spring Boot进阶(68)：如何用SpringBoot轻松实现定时任务？集成Quartz来帮你！(附源码)
**My Coding Family**
09-05 2332
Quartz是一个非常流行的开源调度框架，它提供了许多强大的功能，如定时任务调度、作业管理、任务持久化等。而SpringBoot是目前Java开发中非常流行的框架之一，其对各种开源框架集成非常方便。本篇文章将介绍如何在SpringBoot中集成Quartz，以便于更好的管理和调度定时任务。
Spring Boot进阶(69)：轻松实现定时任务持久化！SpringBoot集成quartz带你玩转定时任务删除、暂停、获取等操作！【附项目源码】
**My Coding Family**
09-06 3277
本篇文章主要介绍了如何使用SpringBoot整合Quartz，并将定时任务写入库中。首先，我们会给出整个项目的架构，然后详细介绍如何配置Quartz，并将定时任务写入库中。最后，我们还会提供一个测试用例，用于验证我们的定时任务是否成功运行
springboot整合quartz的demo
01-30
springboot整合quartz的demo，实现了simpleTrigger和cronTrigger，具体功能如下：项目启动后，每隔两秒输出一串星号，每隔三秒输出一串#号，访问controller后，添加定时任务，十秒后输出访问者的ip
springboot整合Quartz实现动态配置定时任务源码
06-10
springboot整合Quartz实现动态配置定时任务源码
【SpringBoot】调度和执行定时任务--Quartz(超详细)
最新发布
qq_45687669的博客
09-14 1610
}} }Job;import org} }import org} }@Overridetry {// 模拟长时间运行的任务 Thread . sleep(5000);} }try {// 模拟长时间运行的任务 Thread . sleep(5000);} }Job;import orgtry {// 模拟长时间运行的任务 Thread . sleep(5000);
SpringBoot集成Quartz
Yuwen110的博客
07-17 1324
目的：订单 --》Quartz / 延迟队列 / 前端定时器 1、订单未支付倒计时取消 （支付超时） 2、支付之后收获的待确认 （自动确认） ---- 收了货不确认，平台就不会把钱打给 总共4类型订单 1、领养 2、服务 3、goods 4、充值 特殊：充值后不会退钱 一、Quartz quartz工作原理 看不懂了再回看一下详情 Cron表达式，或者直接根据下面的方法，给一个日期转换成Cron表达式。 /** * 将日期转换为cron表达式 *...
springboot集成quartz
weixin_42254034的博客
12-12 789
springboot集成quartz Spring Boot 集成 Quartz 定时任务，并实现对定时任务的管理，包括新增定时任务，删除定时任务，暂停定时任务，恢复定时任务，修改定时任务启动时间，以及定时任务列表查询。 代码地址:https://github.com/DNYDYS/spring-boot-quartz.git 后端 初始化 在 init/dbTables 下选择 Quartz 需要的表结构，然后手动创建表。 pom.xml <?xml version="1.0" encoding="
spring boot集成quartz
m0_72167535的博客
11-17 2953
创建配置文件实现ApplicationRunner接口，实现run方法，在方法中，首先通过反射方式获取到要执行定时任务的类来创建jobdetail，然后根据执行规则创建执行的触发器trigger，再将jobdetail和trigger放到scheduler容器中，按照规则进行任务的执行。定时任务的全路径名称，执行的触发器以及任务名称，可以存放在数据库中，并在前端追加可视化画面来进行修改，删除及立即执行的功能。Quartz 中需要执行的任务详情，包括了任务的唯一标识和具体要执行的任务，可以通过。
SpringBoot+Quartz实现定时任务增删改查操作源码解析
通过分析提供的文件列表，我们可以发现该项目源码被封装在一个名为“java实现定时器的增删改查源码（springboot+quartz）.zip”的压缩包内，包含了项目中通常会用到的配置和说明文件，如.gitattributes、.gitignore...
SpringBoot入门DEMO，基于SpringBoot实现仿小滴课堂项目源代码
08-16
SpringBoot集成Quartz或Spring Task等任务调度库，可以实现定时任务和异步任务。异步任务能提高系统并行处理能力，减少响应时间。在项目中，可能通过`@Async`注解标记方法为异步执行，同时配合`@EnableAsync`开启...
JAVA毕业设计之springboot高校党务系统项目（springboot完整源码+说明）.zip
02-27
通过此项目，你将能掌握SpringBoot的实战应用，理解微服务架构思想，熟悉Java后端开发流程，了解数据库设计与操作，掌握前端页面的构建，以及如何进行系统集成和部署。 8. **项目说明**： 提供的完整源码应包含...
spring boot集成quartz定时器
01-23
spring boot集成quartz定时器,job支持spring的依赖注入
springboot-quartz:springboot整合quartz
05-16
quartz maven创建quart项目，笔记参见项目根目录下README.md Springboot-quartz springboot整合quart项目，笔记参见项目根目录下README.md
springboot+quartz定时任务实现 纯代码
03-30
最新springboot+Quartz实现动态定时任务,源代码. 包括controller,service,impl,和配置文件,pom文件,实体类,直接导入springboot项目,配置好数据库就能使用.欢迎下载好评!
quartzdemo
03-17
NULL 博文链接：https://jsufly.iteye.com/blog/562437
spring-boot-starter-quartz：Quartz-Scheduler的Spring-Boot自动配置
01-31
Quartz Scheduler的Spring-Boot自动配置 只是Quartz Scheduler的Spring-Boot启动器。 当然，Quartz Scheduler已经有好几个启动器，但是它们都不能满足我的所有需求，因此我创建了自己的启动器。 这只是一个业余项目。 使用此工具（尤其是在生产系统中）的风险自负。 内容 需求，依赖 弹簧靴 石英调度器 经过Spring Boot测试 （直到1.0.2）1.3.8、1.4.6、1.5.3、1.5.6， （自1.0.3起）1.4.6、1.5.10、1.5.16、1.5.17 用法 < dependency> < groupId>de.chandre.quartz</ groupId> < artifactId>spring-boot-starter-quartz</ artifactId> < version>1.0.5</ version> </ dependency> 也许您必须显式启用软件包的组件扫描： @SpringBootApplication @EnableAutoConfiguratio
Spring boot 集成 Quartz
Java是世界上最好的语言
10-08 801
Quartz简介 相比于其他定时任务，Quartz具有很大的优势。 首先jdk自带的java.util.Timer类不能在指定时间运行，只能在一些简单场景使用。 其次Spring Task框架虽然使用简单，但是在集群项目中就比较麻烦，不能动态维护。 而Quartz却很好的解决了这些问题。使用该框架我们可以对定时任务随时修改。即使任务已经在调度系统总，我们也可以随时改变任务的调用时间；服务重启之后Quartz的任务也会随之启动，自动根据设置触发器设置的时间执行；同时Quartz还支持集群，一台服务器挂了会转到
spring-boot集成quartz的demo
wltian
01-07 367
spring-boot集成quartz记录demo 引入依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-quartz</artifactId> </dependency> 配置类 @Configuration public class ScheduleConfig { @B
java quartz 源码_Springboot2+Quartz+debug源码教程
weixin_36282234的博客
03-06 257
内容概览：Springboot2+quartz 的简单使用 和 深入源码了解初始化表结构的三个选项Always，Never，Embedded一. pom 文件 引入 quartz jar包org.springframework.bootspring-boot-starter-quartz二. 创建一个job并继承QuartzJobBeanpackage com.java4ye.demo.job;...
SpringBoot与Quartz集成：动态定时任务实战解析
<groupId>org.quartz-scheduler <artifactId>quartz <version>2.2.1 ``` 然后创建实现`Job`接口的自定义任务类，例如`SchedulerQuartzJob1`： ```java package com.yvan.quartz.job; import org.quartz.Job; ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值