Quartz 整合springboot 动态添加、修改和删除定时任务

浅浅的花香味﹌ 2022-12-11 03:15 178阅读 0赞

quartz原理参考:[https://blog.csdn.net/xlxxcc/article/details/52104463][https_blog.csdn.net_xlxxcc_article_details_52104463]

[https://www.cnblogs.com/davidwang456/p/10329616.html][https_www.cnblogs.com_davidwang456_p_10329616.html]

[https://blog.csdn.net/liao0801\_123/article/details/95612495][https_blog.csdn.net_liao0801_123_article_details_95612495]

这里实现了定时任务动态变更. job类可以引用spring-bean功能

pom文件:

1.  `<dependency>`
2.  `<groupId>org.quartz-scheduler</groupId>`
3.  `<artifactId>quartz</artifactId>`
4.  `<version>2.3.0</version>`
5.  `</dependency>`

1:创建一个JobFactory类继承于AdaptableJobFactory。注入AutowireCapableBeansFactory.这样就完成Spring对Job的注入功能

1.  `package com.ss.re.quartz;`
2.   
3.  `import org.quartz.impl.JobDetailImpl;`
4.  `import org.springframework.beans.factory.annotation.Autowired;`
5.  `import org.springframework.context.annotation.Bean;`
6.  `import org.springframework.context.annotation.Configuration;`
7.  `import org.springframework.scheduling.quartz.SchedulerFactoryBean;`
8.   
9.  `@Configuration`
10. `public class QuartzConfig {`
11.  
12. `@Autowired`
13. `private JobFactory jobFactory;`
14.  
15. `@Bean(name = "schedulerFactoryBean")`
16. `public SchedulerFactoryBean createSchedulerFactoryBean(){`
17. `SchedulerFactoryBean schedulerFactoryBean=new SchedulerFactoryBean();`
18. `schedulerFactoryBean.setOverwriteExistingJobs(true);`
19. `schedulerFactoryBean.setJobFactory(jobFactory);`
20. `return schedulerFactoryBean;`
21. `}`
22.  
23. `@Bean`
24. `public JobDetailImpl createJobDetailsImpl(){`
25. `return new JobDetailImpl();`
26. `}`
27. `}`

2.添加一个QuartzConfig类。对Scheduer进行重新配置设置Scheduler的JobFactory使用我们自己创建的JobFactory

3.定义一个job类, 实现org.quartz.job接口,并重写执行方法

1.  `package com.ss.re.quartz;`
2.   
3.   
4.  `import java.util.Date;`
5.   
6.  `import org.quartz.Job;`
7.  `import org.quartz.JobExecutionContext;`
8.  `import org.quartz.JobExecutionException;`
9.  `import org.springframework.beans.factory.annotation.Autowired;`
10. `import org.springframework.context.ApplicationContext;`
11. `import org.springframework.context.ApplicationContextAware;`
12. `import org.springframework.stereotype.Component;`
13.  
14. `import com.ss.re.service.RuleProcessService;`
15.  
16. `@Component`
17. `public class RuleTriggerJob implements Job{`
18.  
19. `@Autowired`
20. `private RuleProcessService service;`
21.  
22.  
23.  
24.  
25. `@Override`
26. `public void execute(JobExecutionContext jobExecutionContext) {`
27. `System.out.println(new Date() + "定时任务执行");`
28. `System.out.println(jobExecutionContext.getJobDetail().getJobDataMap().get("fiterName"));`
29. `service.testInject();`
30.  
31. `}`
32.  
33. `}`

4.定时任务管理类,并实现了对job任务的操作

1.  `package com.ss.re.quartz;`
2.  `import javax.annotation.PostConstruct;`
3.   
4.  `import org.apache.log4j.Logger;`
5.  `import org.quartz.CronScheduleBuilder;`
6.  `import org.quartz.CronTrigger;`
7.  `import org.quartz.JobBuilder;`
8.  `import org.quartz.JobDetail;`
9.  `import org.quartz.JobKey;`
10. `import org.quartz.Scheduler;`
11. `import org.quartz.SchedulerException;`
12. `import org.quartz.SchedulerFactory;`
13. `import org.quartz.Trigger;`
14. `import org.quartz.TriggerBuilder;`
15. `import org.quartz.TriggerKey;`
16. `import org.quartz.impl.StdSchedulerFactory;`
17. `import org.springframework.beans.factory.annotation.Autowired;`
18. `import org.springframework.beans.factory.annotation.Qualifier;`
19. `import org.springframework.scheduling.quartz.SchedulerFactoryBean;`
20. `import org.springframework.stereotype.Component;`
21.  
22. `@Component`
23. `public class QuartzManager {`
24.  
25. `private static Logger logger = Logger.getLogger(QuartzManager.class);`
26.  
27. `@Autowired`
28. `@Qualifier("schedulerFactoryBean")//多个实现类时指定名字`
29. `private SchedulerFactoryBean schedulerFactoryBean;`
30.  
31. `@PostConstruct`
32. `public void registry(){`
33. `scheduler = schedulerFactoryBean.getScheduler();`
34. `}`
35. `private static Scheduler scheduler;`
36.  
37. `private static SchedulerFactory schedulerFactory = new StdSchedulerFactory();`
38.  
39. `/**`
40. `* @Description: 添加一个定时任务`
41. `*`
42. `* @param jobName 任务名`
43. `* @param jobGroupName 任务组名`
44. `* @param triggerName 触发器名`
45. `* @param triggerGroupName 触发器组名`
46. `* @param jobClass 任务`
47. `* @param cron 时间设置，参考quartz说明文档`
48. `*/`
49. `@SuppressWarnings({ "unchecked", "rawtypes" })`
50. `public static void addJob(String jobName, String jobGroupName,`
51. `String triggerName, String triggerGroupName, String cron,String fiterName) {`
52. `try {`
53. `Scheduler sched = scheduler;`
54. `// 任务名，任务组，任务执行类`
55. `JobDetail jobDetail= JobBuilder.newJob(RuleTriggerJob.class).withIdentity(jobName, jobGroupName)`
56. `.usingJobData("fiterName", fiterName)`
57. `.build();`
58.  
59. `// 触发器`
60. `TriggerBuilder<Trigger> triggerBuilder = TriggerBuilder.newTrigger();`
61. `// 触发器名,触发器组`
62. `triggerBuilder.withIdentity(triggerName, triggerGroupName);`
63. `triggerBuilder.startNow();`
64. `// 触发器时间设定`
65. `triggerBuilder.withSchedule(CronScheduleBuilder.cronSchedule(cron));`
66. `// 创建Trigger对象`
67. `CronTrigger trigger = (CronTrigger) triggerBuilder.build();`
68.  
69. `// 调度容器设置JobDetail和Trigger`
70. `sched.scheduleJob(jobDetail, trigger);`
71.  
72. `// 启动`
73. `if (!sched.isShutdown()) {`
74. `sched.start();`
75. `}`
76. `} catch (Exception e) {`
77. `throw new RuntimeException(e);`
78. `}`
79. `}`
80.  
81. `/**`
82. `* @Description: 修改一个任务的触发时间`
83. `*`
84. `* @param jobName`
85. `* @param jobGroupName`
86. `* @param triggerName 触发器名`
87. `* @param triggerGroupName 触发器组名`
88. `* @param cron 时间设置，参考quartz说明文档`
89. `*/`
90. `public static void modifyJobTime(String jobName,`
91. `String jobGroupName, String triggerName, String triggerGroupName, String cron) {`
92. `try {`
93. `Scheduler sched = scheduler;`
94. `TriggerKey triggerKey = TriggerKey.triggerKey(triggerName, triggerGroupName);`
95. `CronTrigger trigger = (CronTrigger) sched.getTrigger(triggerKey);`
96. `if (trigger == null) {`
97. `return;`
98. `}`
99.  
100. `String oldTime = trigger.getCronExpression();`
101. `if (!oldTime.equalsIgnoreCase(cron)) {`
102. `/** 方式一 ：调用 rescheduleJob 开始 */`
103. `// 触发器`
104. `TriggerBuilder<Trigger> triggerBuilder = TriggerBuilder.newTrigger();`
105. `// 触发器名,触发器组`
106. `triggerBuilder.withIdentity(triggerName, triggerGroupName);`
107. `triggerBuilder.startNow();`
108. `// 触发器时间设定`
109. `triggerBuilder.withSchedule(CronScheduleBuilder.cronSchedule(cron));`
110. `// 创建Trigger对象`
111. `trigger = (CronTrigger) triggerBuilder.build();`
112. `// 方式一 ：修改一个任务的触发时间`
113. `sched.rescheduleJob(triggerKey, trigger);`
114. `/** 方式一 ：调用 rescheduleJob 结束 */`
115.  
116. `/** 方式二：先删除，然后在创建一个新的Job */`
117. `//JobDetail jobDetail = sched.getJobDetail(JobKey.jobKey(jobName, jobGroupName));`
118. `//Class<? extends Job> jobClass = jobDetail.getJobClass();`
119. `//removeJob(jobName, jobGroupName, triggerName, triggerGroupName);`
120. `//addJob(jobName, jobGroupName, triggerName, triggerGroupName, jobClass, cron);`
121. `/** 方式二 ：先删除，然后在创建一个新的Job */`
122. `}`
123. `} catch (Exception e) {`
124. `throw new RuntimeException(e);`
125. `}`
126. `}`
127.  
128. `/**`
129. `* @Description: 移除一个任务`
130. `*`
131. `* @param jobName`
132. `* @param jobGroupName`
133. `* @param triggerName`
134. `* @param triggerGroupName`
135. `*/`
136. `public static void removeJob(String jobName, String jobGroupName,`
137. `String triggerName, String triggerGroupName) {`
138. `try {`
139. `Scheduler sched = scheduler;`
140.  
141. `TriggerKey triggerKey = TriggerKey.triggerKey(triggerName, triggerGroupName);`
142.  
143. `sched.pauseTrigger(triggerKey);// 停止触发器`
144. `sched.unscheduleJob(triggerKey);// 移除触发器`
145. `sched.deleteJob(JobKey.jobKey(jobName, jobGroupName));// 删除任务`
146. `} catch (Exception e) {`
147. `throw new RuntimeException(e);`
148. `}`
149. `}`
150.  
151. `/**`
152. `* @Description:启动所有定时任务`
153. `*/`
154. `public static void startJobs() {`
155. `try {`
156. `Scheduler sched = scheduler;`
157. `sched.start();`
158. `} catch (Exception e) {`
159. `throw new RuntimeException(e);`
160. `}`
161. `}`
162.  
163. `/**`
164. `* @Description:关闭所有定时任务`
165. `*/`
166. `public static void shutdownJobs() {`
167. `try {`
168. `Scheduler sched = scheduler;`
169. `if (!sched.isShutdown()) {`
170. `sched.shutdown();`
171. `}`
172. `} catch (Exception e) {`
173. `throw new RuntimeException(e);`
174. `}`
175. `}`
176.  
177. `/**`
178. `* 安全关闭`
179. `* @throws SchedulerException`
180. `*/`
181. `public static void safeShutdown() throws SchedulerException {`
182. `int executingJobSize = scheduler.getCurrentlyExecutingJobs().size();`
183. `logger.info("安全关闭 当前还有" + executingJobSize + "个任务正在执行，等待完成后关闭");`
184. `//等待任务执行完后安全关闭`
185. `scheduler.shutdown(true);`
186.  
187. `logger.info("安全关闭 成功");`
188. `}`
189. `}`

5.测试方法

1.  `public class Test {`
2.   
3.   
4.  `public static String JOB_NAME = "动态任务调度";`
5.  `public static String TRIGGER_NAME = "动态任务触发器";`
6.  `public static String JOB_GROUP_NAME = "XLXXCC_JOB_GROUP";`
7.  `public static String TRIGGER_GROUP_NAME = "XLXXCC_JOB_GROUP";`
8.   
9.  `public static void main(String[] args) {`
10. `/*trigger job名称可以自由定义*/`
11. `try {`
12. `System.out.println("【系统启动】开始(每1秒输出一次)...");`
13. `QuartzManager.addJob(JOB_NAME, JOB_GROUP_NAME, TRIGGER_NAME, TRIGGER_GROUP_NAME, MyJob.class, "0/1 * * * * ?");`
14.  
15. `Thread.sleep(5000);`
16. `System.out.println("【修改时间】开始(每5秒输出一次)...");`
17. `QuartzManager.modifyJobTime(JOB_NAME, JOB_GROUP_NAME, TRIGGER_NAME, TRIGGER_GROUP_NAME, "0/5 * * * * ?");`
18.  
19. `Thread.sleep(6000);`
20. `System.out.println("【移除定时】开始...");`
21. `QuartzManager.removeJob(JOB_NAME, JOB_GROUP_NAME, TRIGGER_NAME, TRIGGER_GROUP_NAME);`
22. `System.out.println("【移除定时】成功");`
23. `} catch (Exception e) {`
24. `e.printStackTrace();`
25. `}`
26. `}`
27. `}`
28.

### SpringBoot集成Quartz ###

定时任务Quartz : 就是在指定的时间执行一次或者循环执行,在项目的开发中有时候会需要的, 还是很有用的.

SpringBoot内置的定时

1.  添加依赖

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

1.  启动类上添加注解

@SpringBootApplication
    @EnableScheduling
    public class SpringbootQuartzApplication {
    }

1.  创建定时执行的任务类(两种方式)

方式一:

@Component
    public class SchedulerTask {
        
        private int count = 0;
        
        /**
         * @Author Smith
         * @Description 设置没6秒执行一次
         * @Date 14:23 2019/1/24
         * @Param 
         * @return void
         **/
        @Scheduled(cron = "*/6 * * * * ?")
        private void process(){
            System.out.println("this is scheduler task running " + (count++));
        }
        
    }

方式二:

@Component
    public class SchedulerTask2 {
        
        private static final SimpleDateFormat dateFormat =
                new SimpleDateFormat("HH:mm:ss");
        
        /**
         * @Author Smith
         * @Description 设置没6秒执行一次
         * @Date 14:22 2019/1/24
         * @Param 
         * @return void
         **/
        @Scheduled(fixedRate = 6000)
        private void process(){
            System.out.println("now time is " + dateFormat.format(new Date()));
        }
        
    }

参数说明

@Scheduled 参数可以接受两种定时的设置，一种是我们常用的 cron="\*/6 \* \* \* \* ?"，一种是 fixedRate = 6000，两种都可表示固定周期执行定时任务。

**fixedRate说明**

*  @Scheduled(fixedRate = 6000)：上一次开始执行时间点之后 6 秒再执行。
 *  @Scheduled(fixedDelay = 6000)：上一次执行完毕时间点之后 6 秒再执行。
 *  @Scheduled(initialDelay=1000, fixedRate=6000)：第一次延迟 1 秒后执行，之后按 fixedRate 的规则每 6 秒执行一次。

**cron说明**

cron一定有七位数,最后一位是年,SpringBoot定时方案只需要设置六位即可:

*  第一位, 表示秒, 取值是0 ~ 59
 *  第二位, 表示分. 取值是0 ~ 59
 *  第三位, 表示小时, 取值是0 ~ 23
 *  第四位, 表示天/日, 取值是0 ~ 31
 *  第五位, 表示月份, 取值是1 ~ 12
 *  第六位, 表示星期, 取值是1 ~ 7, 星期一，星期二...， 还有 1 表示星期日
 *  第七位, 年份, 可以留空, 取值是1970 ~ 2099

cron中,还有一些特殊的符号,含义如下:

*  (\*) 星号，可以理解为每的意思，每秒、每分、每天、每月、每年...。
 *  (?)问号，问号只能出现在日期和星期这两个位置，表示这个位置的值不确定，每天 3 点执行，因此第六位星期的位置，是不需要关注的，就是不确定的值；同时，日期和星期是两个相互排斥的元素，通过问号来表明不指定值，比如 1 月 10 日是星期一，如果在星期的位置另指定星期二，就前后冲突矛盾了。
 *  （-）减号，表达一个范围，如在小时字段中使用“10 - 12”，则表示从 10 到 12 点，即 10、11、12。
 *  （,）逗号，表达一个列表值，如在星期字段中使用“1,2,4”，则表示星期一、星期二、星期四。
 *  （/）斜杠，如 x/y，x 是开始值，y 是步长，比如在第一位（秒），0/15 就是从 0 秒开始，每隔 15 秒执行一次，最后就是 0、15、30、45、60，另 \*/y，等同于 0/y。

举几个例子熟悉一下:

*  0 0 3 \* \* ? ：每天 3 点执行；
 *  0 5 3 \* \* ?：每天 3 点 5 分执行；
 *  0 5 3 ? \* \*：每天 3 点 5 分执行，与上面作用相同；
 *  0 5/10 3 \* \* ?：每天 3 点的 5 分、15 分、25 分、35 分、45 分、55分这几个时间点执行；
 *  0 10 3 ? \* 1：每周星期天，3 点 10 分执行，注，1 表示星期天；
 *  0 10 3 ? \* 1\#3：每个月的第三个星期，星期天执行，\# 号只能出现在星期的位置。

> 基本上SpringBoot自带的定时就是这么简单了.

Quartz

**建议写代码的时候下载下代码来看看目录结构**  
Quartz有四个核心概念:

*  Job：是一个接口，只定义一个方法 execute（JobExecutionContext context），在实现接口的 execute 方法中编写所需要定时执行的 Job（任务），JobExecutionContext 类提供了调度应用的一些信息；Job 运行时的信息保存在 JobDataMap 实例中。
 *  JobDetail：Quartz 每次调度 Job 时，都重新创建一个 Job 实例，因此它不接受一个 Job 的实例，相反它接收一个 Job 实现类（JobDetail，描述 Job 的实现类及其他相关的静态信息，如 Job 名字、描述、关联监听器等信息），以便运行时通过 newInstance() 的反射机制实例化 Job。
 *  rigger：是一个类，描述触发 Job 执行的时间触发规则，主要有 SimpleTrigger 和 CronTrigger 这两个子类。当且仅当需调度一次或者以固定时间间隔周期执行调度，SimpleTrigger 是最适合的选择；而 CronTrigger 则可以通过 Cron 表达式定义出各种复杂时间规则的调度方案：如工作日周一到周五的 15：00 ~ 16：00 执行调度等。
 *  Scheduler：调度器就相当于一个容器，装载着任务和触发器，该类是一个接口，代表一个 Quartz 的独立运行容器，Trigger 和 JobDetail 可以注册到 Scheduler 中，两者在 Scheduler 中拥有各自的组及名称，组及名称是 Scheduler 查找定位容器中某一对象的依据，Trigger 的组及名称必须唯一，JobDetail 的组和名称也必须唯一（但可以和 Trigger 的组和名称相同，因为它们是不同类型的）。Scheduler 定义了多个接口方法，允许外部通过组及名称访问和控制容器中 Trigger 和 JobDetail。

![quartz][]

> Job 为作业的接口，为任务调度的对象；JobDetail 用来描述 Job 的实现类及其他相关的静态信息；Trigger 做为作业的定时管理工具，一个 Trigger 只能对应一个作业实例，而一个作业实例可对应多个触发器；Scheduler 做为定时任务容器，是 Quartz 最上层的东西，它提携了所有触发器和作业，使它们协调工作，每个 Scheduler 都存有 JobDetail 和 Trigger 的注册，一个 Scheduler 中可以注册多个 JobDetail 和多个 Trigger。

整合

1.  引入依赖:

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

1.  定时输出HelloWorld(使用Scheduler 启动)

首先定义一个Job

public class SampleJob extends QuartzJobBean {
    
        private String name;
    
        public void setName(String name) {
            this.name = name;
        }
    
        @Override
        protected void executeInternal(JobExecutionContext jobExecutionContext) throws JobExecutionException {
            System.out.println("Quartz ---->  Hello, " + this.name);
        }
    }

构建JobDetail:

@Configuration
    public class SampleScheduler {
    
        @Bean
        public JobDetail sampleJobDetail() {
            // 链式编程,可以携带多个参数,在Job类中声明属性 + setter方法
            return JobBuilder.newJob(SampleJob.class).withIdentity("sampleJob")
                    .usingJobData("name","World").storeDurably().build();
        }
    
        @Bean
        public Trigger sampleJobTrigger(){
            // 每隔两秒执行一次
            SimpleScheduleBuilder scheduleBuilder =
                    SimpleScheduleBuilder.simpleSchedule().withIntervalInSeconds(2).repeatForever();
            return TriggerBuilder.newTrigger().forJob(sampleJobDetail()).withIdentity("sampleTrigger")
                    .withSchedule(scheduleBuilder).build();
        }
    
    }

*  JobBuilder 无构造函数，只能通过 JobBuilder 的静态方法 newJob(Class jobClass)生成 JobBuilder 实例。
 *  withIdentity 方法可以传入两个参数 withIdentity(String name,String group) 来定义 TriggerKey，也可以不设置，像上文示例中会自动生成一个独一无二的 TriggerKey 用来区分不同的 Trigger。

1.  CronSchedule方式

CronSchedule可以设置更灵活的方式,定时设置与SpringBoot自带的表达式相同.

同理,先定义两个个Job,与ScheduledJob相同,不过实现Job接口,如下:

第一个job:

public class ScheduledJob implements Job {
    
        private String name;
    
        public void setName(String name) {
            this.name = name;
        }
    
        @Override
        public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
    
            SimpleDateFormat dateFormat = new SimpleDateFormat("HH:mm:ss");
    
            System.out.println("CRON ----> schedule job1 is running ... + " + name + "  ---->  " + dateFormat.format(new Date()));
        }
    }

第二个Job

public class ScheduledJob2 implements Job {
    
        private String name;
    
        public void setName(String name) {
            this.name = name;
        }
    
        @Override
        public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
            SimpleDateFormat dateFormat = new SimpleDateFormat("HH:mm:ss");
            System.out.println("CRON ----> schedule job2 is running ... + " + name + "  ---->  " + dateFormat.format(new Date()));
        }
    }

构建Schedule来执行任务:

@Component
    public class CronSchedulerJob {
    
        @Autowired
        private SchedulerFactoryBean schedulerFactoryBean;
    
        private void scheduleJob1(Scheduler scheduler) throws SchedulerException {
            JobDetail jobDetail = JobBuilder.newJob(ScheduledJob.class) .withIdentity("job1", "group1").build();
            // 6的倍数秒执行 也就是 6 12 18 24 30 36 42 ....
            CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule("0/6 * * * * ?");
            CronTrigger cronTrigger = TriggerBuilder.newTrigger().withIdentity("trigger1", "group1")
                    .usingJobData("name","王智1").withSchedule(scheduleBuilder).build();
            scheduler.scheduleJob(jobDetail,cronTrigger);
        }
    
        private void scheduleJob2(Scheduler scheduler) throws SchedulerException{
            JobDetail jobDetail = JobBuilder.newJob(ScheduledJob2.class) .withIdentity("job2", "group2").build();
            // 12秒的倍数执行  12  24 36  48  60
            CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule("0/12 * * * * ?");
            CronTrigger cronTrigger = TriggerBuilder.newTrigger().withIdentity("trigger2", "group2")
                    .usingJobData("name","王智2").withSchedule(scheduleBuilder).build();
            scheduler.scheduleJob(jobDetail,cronTrigger);
        }
    
        /**
         * @Author Smith
         * @Description 同时启动两个定时任务
         * @Date 16:31 2019/1/24
         * @Param
         * @return void
         **/
        public void scheduleJobs() throws SchedulerException {
            Scheduler scheduler = schedulerFactoryBean.getScheduler();
            scheduleJob1(scheduler);
            scheduleJob2(scheduler);
        }
    }

触发定时任务有两种方式:

第一种是项目启动时执行:

@Component
    public class MyStartupRunner implements CommandLineRunner {
    
        @Autowired
        public CronSchedulerJob scheduleJobs;
    
        @Override
        public void run(String... args) throws Exception {
            scheduleJobs.scheduleJobs();
            System.out.println(">>>>>>>>>>>>>>>定时任务开始执行<<<<<<<<<<<<<");
        }
    }

第二种是定时执行:

@Configuration
    @EnableScheduling
    @Component
    public class SchedulerListener {
    
        @Autowired
        public CronSchedulerJob scheduleJobs;
    
        @Scheduled(cron="0 47 16 24 1 ?")
        public void schedule() throws SchedulerException {
            scheduleJobs.scheduleJobs();
            System.out.println(">>>>>>>>>>>>>>>定时任务开始执行<<<<<<<<<<<<<");
        }
    
    }

> 两种启动方案，在项目中选择一种使用即可，否则会导致重复启动定时任务而报错。 所以在测试某一个启动时,将另一个类上的注解注释掉就可以了.

> 我刚开始工作,所以暂时还没遇到定时任务方面需求,但是总感觉这个以后会用,提前学习一下,而且自我感觉这个定时任务也是挺有意思. 在SpringBoot自带的定时器中我不知道能不能传递参数,但是quartz是可以,所以说如果需要传递参数的话就是用quartz绝对没问题.

源码: [https://github.com/MissWangLove/SpringBoot][https_github.com_MissWangLove_SpringBoot]

[https_blog.csdn.net_xlxxcc_article_details_52104463]: https://blog.csdn.net/xlxxcc/article/details/52104463
[https_www.cnblogs.com_davidwang456_p_10329616.html]: https://www.cnblogs.com/davidwang456/p/10329616.html
[https_blog.csdn.net_liao0801_123_article_details_95612495]: https://blog.csdn.net/liao0801_123/article/details/95612495
[quartz]: /images/20221123/539fbf671ada4116ba16ba2c2bab9d85.png
[https_github.com_MissWangLove_SpringBoot]: https://github.com/MissWangLove/SpringBoot