AI 助理
备案控制台登录注册
开发者社区 开发与运维 文章 正文

【springboot-01】整合quartz

2018-06-07 1203
版权
举报
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 1、什么是quartz？　　quartz是一个开源的定时任务框架，具备将定时任务持久化至数据库以及分布式环境下多节点调度的能力。

1、什么是quartz？

　　quartz是一个开源的定时任务框架，具备将定时任务持久化至数据库以及分布式环境下多节点调度的能力。当当的elastic-job便是以quartz为基础，结合zookeeper开发出来的一款产品。

 

2、整合springboot示例

　　项目使用springboot提高开发效率，并将定时任务持久化到mysql数据库中。

2.1）引入quartz依赖

复制代码 
 1 <dependency>
 2     <groupId>org.quartz-scheduler</groupId>
 3     <artifactId>quartz</artifactId>
 4     <version>2.3.0</version>
 5 </dependency>
 6 <dependency>
 7     <groupId>org.quartz-scheduler</groupId>
 8     <artifactId>quartz-jobs</artifactId>
 9     <version>2.3.0</version>
10 </dependency>
复制代码

 

2.2）配置quartz

        先引入配置的config代码，在下一节中对每一段配置进行详细解释：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
/**
  * 分布式定时任务quartz配置
  * Created by chenjunyi on 2018/6/6.
  */
@Configuration
public  class  QuartzConfiguration {
 
     /**
      * quartz的JobFactory，根据注册的JobClass从spring应用上下文中获取job实例
      */
     public  static  class  AutoSpringBeanJobFactory  extends  AdaptableJobFactory  implements  SchedulerContextAware {
 
         /** spring应用上下文 */
         private  ApplicationContext applicationContext;
 
         /** scheduler上下文 */
         private  SchedulerContext   schedulerContext;
 
         /** 需要忽略的属性 */
         private  String[]           ignoredUnknownProperties =  null ;
 
         private  void  setApplicationContext(ApplicationContext applicationContext) {
             this .applicationContext = applicationContext;
         }
 
         @Override
         public  void  setSchedulerContext(SchedulerContext schedulerContext) {
             this .schedulerContext = schedulerContext;
         }
 
         private  void  setIgnoredUnknownProperties(String... ignoredUnknownProperties) {
             this .ignoredUnknownProperties = ignoredUnknownProperties;
         }
 
         @Override
         protected  Object createJobInstance( final  TriggerFiredBundle bundle)  throws  Exception {
             //获取定时任务的clazz，并从spring上下文中获取实例
             Class<?  extends  Job> clazz = bundle.getJobDetail().getJobClass();
             Job job = applicationContext.getBean(clazz);
 
             if  (isEligibleForPropertyPopulation(job)) {
                 //非继承自QuartzJobBean的Job，设置job属性
                 BeanWrapper bw = PropertyAccessorFactory.forBeanPropertyAccess(job);
                 MutablePropertyValues pvs =  new  MutablePropertyValues();
                 if  ( this .schedulerContext !=  null ) {
                     pvs.addPropertyValues( this .schedulerContext);
                 }
                 pvs.addPropertyValues(bundle.getJobDetail().getJobDataMap());
                 pvs.addPropertyValues(bundle.getTrigger().getJobDataMap());
                 if  ( this .ignoredUnknownProperties !=  null ) {
                     for  (String propName :  this .ignoredUnknownProperties) {
                         if  (pvs.contains(propName) && !bw.isWritableProperty(propName)) {
                             pvs.removePropertyValue(propName);
                         }
                     }
                     bw.setPropertyValues(pvs);
                 }  else  {
                     bw.setPropertyValues(pvs,  true );
                 }
             }
             return  job;
         }
 
         private  boolean  isEligibleForPropertyPopulation(Object jobObject) {
             return  (!(jobObject  instanceof  QuartzJobBean));
         }
 
     }
 
     /**
      * 配置任务工厂实例
      * @param applicationContext spring上下文实例
      * @return 任务工厂实例
      */
     @Bean
     public  JobFactory jobFactory(ApplicationContext applicationContext) {
         AutoSpringBeanJobFactory jobFactory =  new  AutoSpringBeanJobFactory();
         jobFactory.setApplicationContext(applicationContext);
         return  jobFactory;
     }
 
     /**
      * 配置任务调度器，使用项目数据源作为quartz数据源
      * @param jobFactory 自定义配置任务工厂
      * @param dataSource 数据源实例
      * @return 任务调度器
      */
     @Bean
     public  SchedulerFactoryBean schedulerFactoryBean(JobFactory jobFactory, DataSource dataSource) {
         SchedulerFactoryBean schedulerFactoryBean =  new  SchedulerFactoryBean();
         //将spring管理job自定义工厂交由调度器维护
         schedulerFactoryBean.setJobFactory(jobFactory);
         //设置覆盖已存在的任务（配置已失效，因为改写了原有的注册方式，JOB注册时便已自动进行替换）
         schedulerFactoryBean.setOverwriteExistingJobs( true );
         //项目启动完成后，等待50秒后开始执行调度器初始化（需要小于JOB的间隔时间）
         schedulerFactoryBean.setStartupDelay( 50 );
         //设置调度器自动运行
         schedulerFactoryBean.setAutoStartup( true );
         //设置数据源，使用与项目统一数据源
         schedulerFactoryBean.setDataSource(dataSource);
         //设置定时调度器命名空间
         schedulerFactoryBean.setSchedulerName( "MY-QUARTZ-SCHEDULER" );
         //设置存储在quartz上文中的Spring应用上下文key
         schedulerFactoryBean.setApplicationContextSchedulerContextKey( "applicationContext" );
         //设置属性
         Properties properties =  new  Properties();
         //设置调度器实例名
         properties.setProperty( "org.quartz.scheduler.instanceName" ,  "SCHEDULER-INSTANCE" );
         //设置调度器实例ID，在cluster中使用，AUTO标识自动生成
         properties.setProperty( "org.quartz.scheduler.instanceId" ,  "AUTO" );
         //禁用rmi配置
         properties.setProperty( "org.quartz.scheduler.rmi.export" ,  "false" );
         //禁用rmi配置
         properties.setProperty( "org.quartz.scheduler.rmi.proxy" ,  "false" );
         //quartz线程池实现类
         properties.setProperty( "org.quartz.threadPool.class" ,  "org.quartz.simpl.SimpleThreadPool" );
         //quartz线程池线程数
         properties.setProperty( "org.quartz.threadPool.threadCount" ,  "10" );
         //quartz线程池线程优先级
         properties.setProperty( "org.quartz.threadPool.threadPriority" ,  "5" );
         //quartz线程池是否自动加载数据库内的定时任务
         properties.setProperty( "org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread" ,  "true" );
         //Job错过执行时间的阈值
         properties.setProperty( "org.quartz.jobStore.misfireThreshold" ,  "60000" );
         //Job持久化方式配置
         properties.setProperty( "org.quartz.jobStore.class" ,  "org.quartz.impl.jdbcjobstore.JobStoreTX" );
         //Job的JDBC持久化驱动，此处配置为MySql
         properties.setProperty( "org.quartz.jobStore.driverDelegateClass" ,  "org.quartz.impl.jdbcjobstore.StdJDBCDelegate" );
         //配置是否使用
         properties.setProperty( "org.quartz.jobStore.useProperties" ,  "false" );
         //持久化的quartz表结构前缀
         properties.setProperty( "org.quartz.jobStore.tablePrefix" ,  "QRTZ_" );
         //是否是集群quartz
         properties.setProperty( "org.quartz.jobStore.isClustered" ,  "true" );
         //集群quartz中节点有效性检查时间间隔
         properties.setProperty( "org.quartz.jobStore.clusterCheckinInterval" ,  "20000" );
         //错过执行时间的Job最大持有数
         properties.setProperty( "org.quartz.jobStore.maxMisfiresToHandleAtATime" ,  "1" );
         schedulerFactoryBean.setQuartzProperties(properties);
         //返回结果
         return  schedulerFactoryBean;
     }
 
}

 

 2.3）编写定时任务

        为了各个定时任务方便注册，使用模板模式定义一个抽象基类。该抽象基类实现 InterruptableJob接口，当然也可以实现其他接口或抽象类（该继承树的顶级接口为org.quartz.Job）。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
/**
  * 抽象定时任务，完成向quartz注册的功能
  * Created by chenjunyi on 2018/6/6.
  */
@Slf4j
public  abstract  class  AbstractScheduler  implements  InterruptableJob {
 
     @Autowired
     private  Scheduler scheduler;
 
     /**
      * 向定时任务调度器注册
      * @throws SchedulerException 注册时发生异常
      */
     @PostConstruct
     protected  void  register()  throws  SchedulerException {
         //任务和触发器名称（若不进行设置，则quartz默认使用UUID，因此每次启动应用都会注册一个新任务）
         String jobName =  this .getClass().getSimpleName() +  "Job" ;
         String triggerName =  this .getClass().getSimpleName() +  "Trigger" ;
         //设置定时任务
         JobDetail jobDetail = JobBuilder.newJob( this .getClass()).withIdentity(jobName).build();
         //创建任务触发器
         CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(getCron());
         Trigger trigger = TriggerBuilder.newTrigger().withIdentity(triggerName).withSchedule(scheduleBuilder).build();
         //将触发器与任务绑定到调度器内
         Set<Trigger> triggers =  new  HashSet<>();
         triggers.add(trigger);
         scheduler.scheduleJob(jobDetail, triggers,  true );
         log.info( ">>>>>注册[Trigger={}, Job={}]的定时任务成功" , triggerName, jobName);
     }
 
     /**
      * 获取cron表达式
      * @return cron表达式
      */
     protected  abstract  String getCron();
 
}

        实现一个自定义的demo定时任务，并通过@Service交于Spring-IOC容器进行托管，代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
/**
  * 示例定时任务
  * Created by chenjunyi on 2018/6/5.
  */
@Service
@PersistJobDataAfterExecution
@DisallowConcurrentExecution
public  class  DemoScheduler  extends  AbstractScheduler {
 
     @Value ( "${env.cron.demoScheduler}" )
     private  String      cron;
 
     @Autowired
     private  DemoService demoService;
 
     @Override
     public  void  interrupt()  throws  UnableToInterruptJobException {
 
     }
 
     @Override
     public  void  execute(JobExecutionContext context)  throws  JobExecutionException {
         demoService.sayHello();
     }
 
     @Override
     protected  String getCron() {
         return  this .cron;
     }
 
}

　　

3、整合代码详解

3.1）AutoSpringBeanJobFactory

        JobFactory，即定时任务Job工厂，在定时任务触发时，通过该factory获取定时任务实例并执行。该接口的继承树比较简单，实现的子类只有2个，如下图所示：
        不论是 AdaptableJobFactory还是SimpleJobFactory，其获取Job实例的方式都比较简单，即通过JobDetail的Class直接newInstance，以AdaptableJobFactory为例，相关源码如下：
1
2
3
4
5
6
7
8
9
10
11
12
13
@Override
public  Job newJob(TriggerFiredBundle bundle, Scheduler scheduler)  throws  SchedulerException {
     try  {
         Object jobObject = createJobInstance(bundle);  //直接根据class.newInstance获取实例
         return  adaptJob(jobObject);  //job适配，判断job类型并进行包装，此处忽略
     }  catch  (Exception ex) {
         throw  new  SchedulerException( "Job instantiation failed" , ex);
     }
}
 
protected  Object createJobInstance(TriggerFiredBundle bundle)  throws  Exception {
     return  bundle.getJobDetail().getJobClass().newInstance();
}
　　但这样带来了一个问题，因为我们的定时任务可能会依赖spring-ioc容器中的其他bean（需要进行注入），直接newInstance创建的实例无法被spring-ioc容器托管，从而在执行时拿不到注入的对象，导致NPE（NullPointException）。为了解决这个问题，在网上搜索了解决办法，给出的思路基本都是通过newInstance拿到Job对象后，再手动将其托管到spring-ioc容器中，如下代码所示：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
//参考博客链接：https://www.jianshu.com/p/d52d62fb2ac6；作者：恒宇少年
public  static  class  AutowiringSpringBeanJobFactory  extends  SpringBeanJobFactory  implements  ApplicationContextAware {
 
     /** spring-beanfactory */
     private  transient  AutowireCapableBeanFactory beanFactory;
 
     @Override
     public  void  setApplicationContext( final  ApplicationContext context) {
         beanFactory = context.getAutowireCapableBeanFactory();
     }
 
     @Override
     protected  Object createJobInstance( final  TriggerFiredBundle bundle)  throws  Exception {
         final  Object job =  super .createJobInstance(bundle);
         beanFactory.autowireBean(job);  //通过newInstance获取job实例后，将其交付给spring-ioc
         return  job;
     }
}
　　通过在 AutowiringSpringBeanJobFactory中维护一个AutowireCapableBeanFactory，并且在获取Job实例之后使用autowireBean方法将其交给spring-ioc进行托管，从而保证该实例在执行过程中能够拿到注入的对象。
　　这样的处理同样有个问题，就是每次触发定时任务时，都要newInstance创建对象，那么能不能让Job在spring-ioc容器启动时便被托管（即使用 @Service等注解），然后直接获取到这个托管的对象呢？解决这个问题的思路在于获取Job实例的方式，既然我们可以获取到Job的Class（由Job在向Scheduler注册时设置），那么便可以通过ApplicationContext拿到相应的实例。
　　因此，在AutoSpringBeanJobFactory中，取代了AutowireCapableBeanFactory，维护一个 ApplicationContext，并通过Job的Class获取实例。
1
2
Class<?  extends  Job> clazz = bundle.getJobDetail().getJobClass();
Job job = applicationContext.getBean(clazz);

 

3.2）AbstractScheduler

　　该抽象基类实现了自动注册的逻辑，不需要在config中配置额外的注册。思路是通过 @PostConstruct注解，在该类被Spring完成初始化后，执行注册动作，有以下几点需要注意：
  • 需要设置任务和触发器名称。如果不设置，quartz默认使用UUID，因此每次启动应用都会注册一个新任务；
  • 调度器的绑定，要使用含有replace功能的方法（方法参数带有boolean replace的）。由于是将Job持久化到数据库，应用再次启动时，会读取数据库中的任务列表。不含replace功能的方法在进行一次新的注册时，发现任务已存在的话，就会报错；而含replace功能的方法会更新数据库的Job配置信息；
  • 由于我们在Job初始化时便进行了任务注册，且采用的是replace的方式，因此在config中的schedulerFactoryBean.setOverwriteExistingJobs(true)参数配置便失效了（因为SchedulerFactoryBean在afterPropertiesSet这个属于SpringBean的生命周期方法中，调用了自身的registerJobsAndTriggers方法，该方法会根据此参数决定是否调用含replace功能的绑定方法进行更新Job，我们自己的Job注册实现中便完成了此功能）；
  • 继续上一条，值得注意的是，SchedulerFactoryBean.registerJobsAndTriggers的方法中，会根据是否设置了TransactionManager来决定是否将所有Job和Trigger的更新放在同一个事务中，由于目前的应用没有需要使用事务来更新Job的需求，并且若更新失败，启动应用时会抛出异常，因此该问题放置待解决（解决办法也很简单，在register方法中添加事务控制即可）；

 

 3.3）quartz持久化的表

　　是的，这些表需要手工创建，建表语句如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
DROP  TABLE  IF EXISTS QRTZ_FIRED_TRIGGERS;
DROP  TABLE  IF EXISTS QRTZ_PAUSED_TRIGGER_GRPS;
DROP  TABLE  IF EXISTS QRTZ_SCHEDULER_STATE;
DROP  TABLE  IF EXISTS QRTZ_LOCKS;
DROP  TABLE  IF EXISTS QRTZ_SIMPLE_TRIGGERS;
DROP  TABLE  IF EXISTS QRTZ_SIMPROP_TRIGGERS;
DROP  TABLE  IF EXISTS QRTZ_CRON_TRIGGERS;
DROP  TABLE  IF EXISTS QRTZ_BLOB_TRIGGERS;
DROP  TABLE  IF EXISTS QRTZ_TRIGGERS;
DROP  TABLE  IF EXISTS QRTZ_JOB_DETAILS;
DROP  TABLE  IF EXISTS QRTZ_CALENDARS;
 
 
CREATE  TABLE  QRTZ_JOB_DETAILS
   (
     SCHED_NAME  VARCHAR (120)  NOT  NULL ,
     JOB_NAME   VARCHAR (200)  NOT  NULL ,
     JOB_GROUP  VARCHAR (200)  NOT  NULL ,
     DESCRIPTION  VARCHAR (250)  NULL ,
     JOB_CLASS_NAME    VARCHAR (250)  NOT  NULL ,
     IS_DURABLE  VARCHAR (1)  NOT  NULL ,
     IS_NONCONCURRENT  VARCHAR (1)  NOT  NULL ,
     IS_UPDATE_DATA  VARCHAR (1)  NOT  NULL ,
     REQUESTS_RECOVERY  VARCHAR (1)  NOT  NULL ,
     JOB_DATA BLOB  NULL ,
     PRIMARY  KEY  (SCHED_NAME,JOB_NAME,JOB_GROUP)
);
 
CREATE  TABLE  QRTZ_TRIGGERS
   (
     SCHED_NAME  VARCHAR (120)  NOT  NULL ,
     TRIGGER_NAME  VARCHAR (200)  NOT  NULL ,
     TRIGGER_GROUP  VARCHAR (200)  NOT  NULL ,
     JOB_NAME   VARCHAR (200)  NOT  NULL ,
     JOB_GROUP  VARCHAR (200)  NOT  NULL ,
     DESCRIPTION  VARCHAR (250)  NULL ,
     NEXT_FIRE_TIME  BIGINT (13)  NULL ,
     PREV_FIRE_TIME  BIGINT (13)  NULL ,
     PRIORITY  INTEGER  NULL ,
     TRIGGER_STATE  VARCHAR (16)  NOT  NULL ,
     TRIGGER_TYPE  VARCHAR (8)  NOT  NULL ,
     START_TIME  BIGINT (13)  NOT  NULL ,
     END_TIME  BIGINT (13)  NULL ,
     CALENDAR_NAME  VARCHAR (200)  NULL ,
     MISFIRE_INSTR  SMALLINT (2)  NULL ,
     JOB_DATA BLOB  NULL ,
     PRIMARY  KEY  (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
     FOREIGN  KEY  (SCHED_NAME,JOB_NAME,JOB_GROUP)
         REFERENCES  QRTZ_JOB_DETAILS(SCHED_NAME,JOB_NAME,JOB_GROUP)
);
 
CREATE  TABLE  QRTZ_SIMPLE_TRIGGERS
   (
     SCHED_NAME  VARCHAR (120)  NOT  NULL ,
     TRIGGER_NAME  VARCHAR (200)  NOT  NULL ,
     TRIGGER_GROUP  VARCHAR (200)  NOT  NULL ,
     REPEAT_COUNT  BIGINT (7)  NOT  NULL ,
     REPEAT_INTERVAL  BIGINT (12)  NOT  NULL ,
     TIMES_TRIGGERED  BIGINT (10)  NOT  NULL ,
     PRIMARY  KEY  (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
     FOREIGN  KEY  (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
         REFERENCES  QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
);
 
CREATE  TABLE  QRTZ_CRON_TRIGGERS
   (
     SCHED_NAME  VARCHAR (120)  NOT  NULL ,
     TRIGGER_NAME  VARCHAR (200)  NOT  NULL ,
     TRIGGER_GROUP  VARCHAR (200)  NOT  NULL ,
     CRON_EXPRESSION  VARCHAR (200)  NOT  NULL ,
     TIME_ZONE_ID  VARCHAR (80),
     PRIMARY  KEY  (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
     FOREIGN  KEY  (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
         REFERENCES  QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
);
 
CREATE  TABLE  QRTZ_SIMPROP_TRIGGERS
   (         
     SCHED_NAME  VARCHAR (120)  NOT  NULL ,
     TRIGGER_NAME  VARCHAR (200)  NOT  NULL ,
     TRIGGER_GROUP  VARCHAR (200)  NOT  NULL ,
     STR_PROP_1  VARCHAR (512)  NULL ,
     STR_PROP_2  VARCHAR (512)  NULL ,
     STR_PROP_3  VARCHAR (512)  NULL ,
     INT_PROP_1  INT  NULL ,
     INT_PROP_2  INT  NULL ,
     LONG_PROP_1  BIGINT  NULL ,
     LONG_PROP_2  BIGINT  NULL ,
     DEC_PROP_1  NUMERIC (13,4)  NULL ,
     DEC_PROP_2  NUMERIC (13,4)  NULL ,
     BOOL_PROP_1  VARCHAR (1)  NULL ,
     BOOL_PROP_2  VARCHAR (1)  NULL ,
     PRIMARY  KEY  (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
     FOREIGN  KEY  (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
     REFERENCES  QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
);
 
CREATE  TABLE  QRTZ_BLOB_TRIGGERS
   (
     SCHED_NAME  VARCHAR (120)  NOT  NULL ,
     TRIGGER_NAME  VARCHAR (200)  NOT  NULL ,
     TRIGGER_GROUP  VARCHAR (200)  NOT  NULL ,
     BLOB_DATA BLOB  NULL ,
     PRIMARY  KEY  (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
     FOREIGN  KEY  (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
         REFERENCES  QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
);
 
CREATE  TABLE  QRTZ_CALENDARS
   (
     SCHED_NAME  VARCHAR (120)  NOT  NULL ,
     CALENDAR_NAME   VARCHAR (200)  NOT  NULL ,
     CALENDAR BLOB  NOT  NULL ,
     PRIMARY  KEY  (SCHED_NAME,CALENDAR_NAME)
);
 
CREATE  TABLE  QRTZ_PAUSED_TRIGGER_GRPS
   (
     SCHED_NAME  VARCHAR (120)  NOT  NULL ,
     TRIGGER_GROUP   VARCHAR (200)  NOT  NULL ,
     PRIMARY  KEY  (SCHED_NAME,TRIGGER_GROUP)
);
 
CREATE  TABLE  QRTZ_FIRED_TRIGGERS
   (
     SCHED_NAME  VARCHAR (120)  NOT  NULL ,
     ENTRY_ID  VARCHAR (95)  NOT  NULL ,
     TRIGGER_NAME  VARCHAR (200)  NOT  NULL ,
     TRIGGER_GROUP  VARCHAR (200)  NOT  NULL ,
     INSTANCE_NAME  VARCHAR (200)  NOT  NULL ,
     FIRED_TIME  BIGINT (13)  NOT  NULL ,
     SCHED_TIME  BIGINT (13)  NOT  NULL ,
     PRIORITY  INTEGER  NOT  NULL ,
     STATE  VARCHAR (16)  NOT  NULL ,
     JOB_NAME  VARCHAR (200)  NULL ,
     JOB_GROUP  VARCHAR (200)  NULL ,
     IS_NONCONCURRENT  VARCHAR (1)  NULL ,
     REQUESTS_RECOVERY  VARCHAR (1)  NULL ,
     PRIMARY  KEY  (SCHED_NAME,ENTRY_ID)
);
 
CREATE  TABLE  QRTZ_SCHEDULER_STATE
   (
     SCHED_NAME  VARCHAR (120)  NOT  NULL ,
     INSTANCE_NAME  VARCHAR (200)  NOT  NULL ,
     LAST_CHECKIN_TIME  BIGINT (13)  NOT  NULL ,
     CHECKIN_INTERVAL  BIGINT (13)  NOT  NULL ,
     PRIMARY  KEY  (SCHED_NAME,INSTANCE_NAME)
);
 
CREATE  TABLE  QRTZ_LOCKS
   (
     SCHED_NAME  VARCHAR (120)  NOT  NULL ,
     LOCK_NAME   VARCHAR (40)  NOT  NULL ,
     PRIMARY  KEY  (SCHED_NAME,LOCK_NAME)
);
 
commit ;
文章标签：
Java
调度
Spring
容器
数据库
关键词：
Spring boot quartz
springboot Quartz
java架构
+关注
112文章
目录
打赏
0
0
0
0
27
分享
相关文章
VipSoft
|
9月前
|
Java 关系型数据库 MySQL
SpringBoot 集成 Quartz + MySQL
SpringBoot 集成 Quartz + MySQL
VipSoft
182 1
好奇的菜鸟
|
11月前
|
SQL API 调度
Springboot2.4.5集成Quartz实现动态任务数据持久化-不怕重启服务
Springboot2.4.5集成Quartz实现动态任务数据持久化-不怕重启服务
好奇的菜鸟
435 0
多多!
|
11月前
|
Java API 调度
Web后端Javaee企业级开发之定时任务 Springboot整合任务框架Quartz和Task详解
Web后端Javaee企业级开发之定时任务 Springboot整合任务框架Quartz和Task详解
多多!
132 0
源码宝
|
12月前
|
存储 数据可视化 安全
Java全套智慧校园系统源码springboot+elmentui +Quartz可视化校园管理平台系统源码 建设智慧校园的5大关键技术
智慧校园指的是以物联网为基础的智慧化的校园工作、学习和生活一体化环境，这个一体化环境以各种应用服务系统为载体，将教学、科研、管理和校园生活进行充分融合。无处不在的网络学习、融合创新的网络科研、透明高效的校务治理、丰富多彩的校园文化、方便周到的校园生活。简而言之，“要做一个安全、稳定、环保、节能的校园。
源码宝
272 6
xiaohua616
|
12月前
|
Java Spring 容器
SpringBoot 使用Quartz执行定时任务对象时无法注入Bean问题
SpringBoot 使用Quartz执行定时任务对象时无法注入Bean问题
xiaohua616
441 1
小z1
|
12月前
|
存储 NoSQL Java
【十】springboot整合quartz实现定时任务优化
【十】springboot整合quartz实现定时任务优化
小z1
161 0
java开发-郭老师
|
12月前
|
SQL Java 调度
SpringBoot集成quartz定时任务trigger_state状态ERROR解决办法
SpringBoot集成quartz定时任务trigger_state状态ERROR解决办法
java开发-郭老师
765 0
风水道人
|
12月前
|
XML Java API
Spring Boot 整合 Quartz 实现 Java 定时任务的动态配置
Spring Boot 整合 Quartz 实现 Java 定时任务的动态配置
风水道人
276 0
终有救赎
|
12月前
|
Java 调度
SpringBoot中实现定时任务(Quartz)（二）
SpringBoot中实现定时任务(Quartz)
终有救赎
145 0
SpringBoot中实现定时任务(Quartz)（二）
终有救赎
|
12月前
|
Java 调度 Spring
SpringBoot中实现定时任务(Quartz)（一）
SpringBoot中实现定时任务(Quartz)
终有救赎
335 0
SpringBoot中实现定时任务(Quartz)（一）

热门文章

最新文章

  • 1
    Spring AI与DeepSeek实战四：系统API调用
    4
  • 2
    Java 开发玩转 MCP：从 Claude 自动化到 Spring AI Alibaba 生态整合
    79
  • 3
    MCP协议重大升级，Spring AI Alibaba联合Higress发布业界首个Streamable HTTP实现方案
    58
  • 4
    深入解析 @Transactional——Spring 事务管理的核心
    4
  • 5
    Java 开发玩转 MCP：从 Claude 自动化到 Spring AI Alibaba 生态整合
    54
  • 6
    AI大模型进阶系列(02)基于Spring AI实现AI chatbot助理|一句话让deepseek实现
    11
  • 7
    保姆级Spring AI 注解式开发教程,你肯定想不到还能这么玩!
    6
  • 8
    Spring Cloud OpenFeign详解与实践
    10
  • 9
    Spring Security 入门与详解
    3
  • 10
    Spring Security 实战指南：从入门到精通
    6
  • 1
    通用快照方案问题之Martin Flower提出的微服务之间的通信如何解决
    75
  • 2
    Spring Boot程序的打包与运行：构建高效部署流程
    309
  • 3
    MyBatis-Plus整合SpringBoot及使用
    481
  • 4
    SpringBoot异步任务获取HttpServletRequest
    535
  • 5
    MyBatis-Plus整合SpringBoot及使用
    195
  • 6
    SpringBoot异步任务获取HttpServletRequest
    190
  • 7
    Spring Boot微服务部署与监控的实战指南
    422
  • 8
    实时计算 Flink版产品使用问题之Spring Boot集成Flink可以通过什么方式实现通过接口启动和关闭Flink程序
    324
  • 9
    实时计算 Flink版产品使用问题之使用Spring Boot启动Flink处理任务时，使用Spring Boot的@Scheduled注解进行定时任务调度，出现内存占用过高，该怎么办
    205
  • 10
    2024最新首发，全网最全 Spring Boot 学习宝典(附思维导图)
    623

    • 相关课程

    更多
  • SpringBoot快速掌握 - 核心技术
  • SpringBoot快速掌握 - 高级应用
  • Java Web开发系列课程 - Spring框架入门
  • Spring Boot 2.5.x开发实战
  • Springboot项目云开发快速迁移
  • Spring Cloud微服务架构设计与开发实战

    • 相关电子书

    更多
  • 云栖社区特邀专家徐雷Java Spring Boot开发实战系列课程（第20讲）：经典面试题与阿里等名企内部招聘求职面试技巧
  • 微服务架构模式与原理Spring Cloud开发实战
  • 阿里特邀专家徐雷Java Spring Boot开发实战系列课程（第18讲）：制作Java Docker镜像与推送到DockerHub和阿里云Docker仓库

    • 相关实验场景

    更多
  • 从零搭建Spring Boot的Hello World
    • 下一篇
    阿里云对象存储OSS收费标准：500G存储118元1年、
    目录
    AI助理

    你好，我是AI助理

    可以解答问题、推荐解决方案等