spring boot 整合quartz集群

最新推荐文章于 2024-02-23 15:03:09 发布
最新推荐文章于 2024-02-23 15:03:09 发布
阅读量543 收藏
点赞数
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/july_young/article/details/82385555
版权 
server:
  port: 8081

spring:
  datasource:
        name: test
        url: jdbc:mysql://127.0.0.1:3306/test
        username: root
        password: 1234
        # 使用druid数据源
        type: com.alibaba.druid.pool.DruidDataSource
        driver-class-name: com.mysql.jdbc.Driver
        filters: stat
        maxActive: 20
        initialSize: 1
        maxWait: 60000
        minIdle: 1
        timeBetweenEvictionRunsMillis: 60000
        minEvictableIdleTimeMillis: 300000
        validationQuery: select 'x'
        testWhileIdle: true
        testOnBorrow: false
        testOnReturn: false
        poolPreparedStatements: true
        maxOpenPreparedStatements: 20

mybatis:
  mapper-locations: classpath:mapper/*.xml
  type-aliases-package: com.winter.entity


org:
  quartz:
    scheduler:
      instanceid: AUTO
      instanceName: DefaultQuartzScheduler
    jobStore:
      useProperties: false
      isClustered: true
      tablePrefix: QRTZ_
      misfireThreshold: 60000
      class: org.quartz.impl.jdbcjobstore.JobStoreTX
      dataSource: myDS
      clusterCheckinInterval: 20000
      driverDelegateClass: org.quartz.impl.jdbcjobstore.StdJDBCDelegate
    threadPool:
      threadCount: 25
      threadPriority: 5
      class: org.quartz.simpl.SimpleThreadPool
    dataSource:
      myDS:
        password: 1234
        validationQuery: select 0 from dual
        driver: com.mysql.jdbc.Driver
        user: root
        URL: jdbc:mysql://127.0.0.1:3306/test?useUnicode=true&characterEncoding=utf-8&useSSL=false&allowMultiQueries=true
        maxConnections: 5

import com.winter.entity.URLPermission;
import com.winter.service.URLPermissionService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.Random;

//需要交由spring管理
@Service("dialogJob")
public class DialogJob {

    @Autowired
    private URLPermissionService urlPermissionService;
    // 方法名在quartz定义
     public void execute() throws Exception{
      //具体执行业务
//      String url =""+ new Random().nextInt(1000);
//      URLPermission urlPermission = new URLPermission(url,"ROLE_ADMIN","GET");
//
//      urlPermissionService.insert(urlPermission);

     }

}

 

 

import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.context.ApplicationContext;
import org.springframework.scheduling.quartz.QuartzJobBean;

import java.lang.reflect.Method;

public class InvokingJobDetailDetailFactory extends QuartzJobBean {
    // 计划任务所在类
    private String targetObject;
    // 具体需要执行的计划任务
    private String targetMethod;
    private ApplicationContext ctx;

    @Override
    protected void executeInternal(JobExecutionContext context) throws JobExecutionException {
        try {
            Object otargetObject = ctx.getBean(targetObject);
            Method m = null;
            try {
                m = otargetObject.getClass().getMethod(targetMethod);
                m.invoke(otargetObject);
            } catch (SecurityException e) {
                e.printStackTrace();
            } catch (NoSuchMethodException e) {
                e.printStackTrace();
            }
        } catch (Exception e) {
            throw new JobExecutionException(e);
        }
    }

    public void setApplicationContext(ApplicationContext applicationContext) {
        this.ctx = applicationContext;
    }

    public void setTargetObject(String targetObject) {
        this.targetObject = targetObject;
    }

    public void setTargetMethod(String targetMethod) {
        this.targetMethod = targetMethod;
    }
}

 

import org.quartz.JobDetail;
import org.quartz.Trigger;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.quartz.CronTriggerFactoryBean;
import org.springframework.scheduling.quartz.JobDetailFactoryBean;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;

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

@Configuration
public class QuartzConfig {

 private String quartzInstanceName="DefaultQuartzScheduler";
  
 @Value("${org.quartz.dataSource.myDS.driver}")
 private String myDSDriver;
  
 @Value("${org.quartz.dataSource.myDS.URL}")
 private String myDSURL;
  
 @Value("${org.quartz.dataSource.myDS.user}")
 private String myDSUser;
  
 @Value("${org.quartz.dataSource.myDS.password}")
 private String myDSPassword;
  
 @Value("${org.quartz.dataSource.myDS.maxConnections}")
 private String myDSMaxConnections;
  
  
 /**
  * 设置属性
  * @return
  * @throws IOException
  */
 private Properties quartzProperties() throws IOException {
  Properties prop = new Properties();
  prop.put("quartz.scheduler.instanceName", quartzInstanceName);
  prop.put("org.quartz.scheduler.instanceId", "AUTO");
  prop.put("org.quartz.scheduler.skipUpdateCheck", "true");
  prop.put("org.quartz.scheduler.jmx.export", "true");
   
  prop.put("org.quartz.jobStore.class", "org.quartz.impl.jdbcjobstore.JobStoreTX");
  prop.put("org.quartz.jobStore.driverDelegateClass", "org.quartz.impl.jdbcjobstore.StdJDBCDelegate");
  prop.put("org.quartz.jobStore.dataSource", "quartzDataSource");
  prop.put("org.quartz.jobStore.tablePrefix", "QRTZ_");
  prop.put("org.quartz.jobStore.isClustered", "true");
   
  prop.put("org.quartz.jobStore.clusterCheckinInterval", "20000");
  prop.put("org.quartz.jobStore.dataSource", "myDS");
  prop.put("org.quartz.jobStore.maxMisfiresToHandleAtATime", "1");
  prop.put("org.quartz.jobStore.misfireThreshold", "120000");
  prop.put("org.quartz.jobStore.txIsolationLevelSerializable", "true");
  prop.put("org.quartz.jobStore.selectWithLockSQL", "SELECT * FROM {0}LOCKS WHERE LOCK_NAME = ? FOR UPDATE");
   
  prop.put("org.quartz.threadPool.class", "org.quartz.simpl.SimpleThreadPool");
  prop.put("org.quartz.threadPool.threadCount", "10");
  prop.put("org.quartz.threadPool.threadPriority", "5");
  prop.put("org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread", "true");
   
  prop.put("org.quartz.dataSource.myDS.driver", myDSDriver);
  prop.put("org.quartz.dataSource.myDS.URL", myDSURL);
  prop.put("org.quartz.dataSource.myDS.user", myDSUser);
  prop.put("org.quartz.dataSource.myDS.password", myDSPassword);
  System.out.println("myDSMaxConnections:" + myDSMaxConnections);
  prop.put("org.quartz.dataSource.myDS.maxConnections", myDSMaxConnections);
   
  prop.put("org.quartz.plugin.triggHistory.class", "org.quartz.plugins.history.LoggingJobHistoryPlugin");
  prop.put("org.quartz.plugin.shutdownhook.class", "org.quartz.plugins.management.ShutdownHookPlugin");
  prop.put("org.quartz.plugin.shutdownhook.cleanShutdown", "true");
  return prop;
 }
  
 @Bean
 public SchedulerFactoryBean schedulerFactoryBean(@Qualifier("dialogJobTrigger") Trigger cronJobTrigger) throws IOException {
  SchedulerFactoryBean factory = new SchedulerFactoryBean(); 
  // this allows to update triggers in DB when updating settings in config file: 
  //用于quartz集群,QuartzScheduler 启动时更新己存在的Job，这样就不用每次修改targetObject后删除qrtz_job_details表对应记录了 
  factory.setOverwriteExistingJobs(true); 
  //用于quartz集群,加载quartz数据源 
  //factory.setDataSource(dataSource); 
  //QuartzScheduler 延时启动，应用启动完10秒后 QuartzScheduler 再启动 
  factory.setStartupDelay(10);
  //用于quartz集群,加载quartz数据源配置 
  factory.setQuartzProperties(quartzProperties());
  factory.setAutoStartup(true);
  factory.setApplicationContextSchedulerContextKey("applicationContext");
  //注册触发器 
  factory.setTriggers(cronJobTrigger);//直接使用配置文件
//  factory.setConfigLocation(new FileSystemResource(this.getClass().getResource("/quartz.properties").getPath()));
  return factory; 
 }
  
  
 /**
  * 加载job
  * @return
  */
 @Bean 
 public JobDetailFactoryBean updateDialogStatusJobDetail() {
  return createJobDetail(InvokingJobDetailDetailFactory.class, "updateDialogStatusGroup", "dialogJob"); 
 } 
 
 /**
  * 加载触发器
  * @param jobDetail
  * @return
  */
 @Bean(name = "dialogJobTrigger") 
 public CronTriggerFactoryBean dialogStatusJobTrigger(@Qualifier("updateDialogStatusJobDetail") JobDetail jobDetail) {
  return dialogStatusTrigger(jobDetail, "0 0/1 * * * ? ");
 } 
 
 /**
  * 创建job工厂
  * @param jobClass
  * @param groupName
  * @param targetObject
  * @return
  */
 private static JobDetailFactoryBean createJobDetail(Class<?> jobClass, String groupName, String targetObject) { 
  JobDetailFactoryBean factoryBean = new JobDetailFactoryBean(); 
  factoryBean.setJobClass(jobClass); 
  factoryBean.setDurability(true); 
  factoryBean.setRequestsRecovery(true);
  factoryBean.setGroup(groupName);
  Map<String, String> map = new HashMap<>();
  map.put("targetObject", targetObject);
  map.put("targetMethod", "execute");
  factoryBean.setJobDataAsMap(map);
  return factoryBean; 
 } 
 
 /**
  * 创建触发器工厂
  * @param jobDetail
  * @param cronExpression
  * @return
  */
 private static CronTriggerFactoryBean dialogStatusTrigger(JobDetail jobDetail, String cronExpression) { 
  CronTriggerFactoryBean factoryBean = new CronTriggerFactoryBean(); 
  factoryBean.setJobDetail(jobDetail);
  factoryBean.setCronExpression (cronExpression);
  return factoryBean; 
 } 
}

数据库脚本：

CREATE DATABASE /*!32312 IF NOT EXISTS*/`test` /*!40100 DEFAULT CHARACTER SET utf8 */;

USE `test`;

/*Table structure for table `qrtz_blob_triggers` */

DROP TABLE IF EXISTS `qrtz_blob_triggers`;

CREATE TABLE `qrtz_blob_triggers` (
  `SCHED_NAME` varchar(120) NOT NULL,
  `TRIGGER_NAME` varchar(120) NOT NULL,
  `TRIGGER_GROUP` varchar(120) NOT NULL,
  `BLOB_DATA` blob,
  PRIMARY KEY (`SCHED_NAME`,`TRIGGER_NAME`,`TRIGGER_GROUP`),
  KEY `SCHED_NAME` (`SCHED_NAME`,`TRIGGER_NAME`,`TRIGGER_GROUP`),
  CONSTRAINT `qrtz_blob_triggers_ibfk_1` FOREIGN KEY (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`) REFERENCES `qrtz_triggers` (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

/*Data for the table `qrtz_blob_triggers` */

/*Table structure for table `qrtz_calendars` */

DROP TABLE IF EXISTS `qrtz_calendars`;

CREATE TABLE `qrtz_calendars` (
  `SCHED_NAME` varchar(120) NOT NULL,
  `CALENDAR_NAME` varchar(120) NOT NULL,
  `CALENDAR` blob NOT NULL,
  PRIMARY KEY (`SCHED_NAME`,`CALENDAR_NAME`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

/*Data for the table `qrtz_calendars` */

/*Table structure for table `qrtz_cron_triggers` */

DROP TABLE IF EXISTS `qrtz_cron_triggers`;

CREATE TABLE `qrtz_cron_triggers` (
  `SCHED_NAME` varchar(120) NOT NULL,
  `TRIGGER_NAME` varchar(120) NOT NULL,
  `TRIGGER_GROUP` varchar(120) NOT NULL,
  `CRON_EXPRESSION` varchar(120) NOT NULL,
  `TIME_ZONE_ID` varchar(80) DEFAULT NULL,
  PRIMARY KEY (`SCHED_NAME`,`TRIGGER_NAME`,`TRIGGER_GROUP`),
  CONSTRAINT `qrtz_cron_triggers_ibfk_1` FOREIGN KEY (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`) REFERENCES `qrtz_triggers` (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

/*Data for the table `qrtz_cron_triggers` */

insert  into `qrtz_cron_triggers`(`SCHED_NAME`,`TRIGGER_NAME`,`TRIGGER_GROUP`,`CRON_EXPRESSION`,`TIME_ZONE_ID`) values ('schedulerFactoryBean','dialogJobTrigger','DEFAULT','0 0/1 * * * ? ','Asia/Shanghai');

/*Table structure for table `qrtz_fired_triggers` */

DROP TABLE IF EXISTS `qrtz_fired_triggers`;

CREATE TABLE `qrtz_fired_triggers` (
  `SCHED_NAME` varchar(120) NOT NULL,
  `ENTRY_ID` varchar(95) NOT NULL,
  `TRIGGER_NAME` varchar(120) NOT NULL,
  `TRIGGER_GROUP` varchar(120) NOT NULL,
  `INSTANCE_NAME` varchar(120) NOT NULL,
  `FIRED_TIME` bigint(13) NOT NULL,
  `SCHED_TIME` bigint(13) NOT NULL,
  `PRIORITY` int(11) NOT NULL,
  `STATE` varchar(16) NOT NULL,
  `JOB_NAME` varchar(120) DEFAULT NULL,
  `JOB_GROUP` varchar(120) DEFAULT NULL,
  `IS_NONCONCURRENT` varchar(1) DEFAULT NULL,
  `REQUESTS_RECOVERY` varchar(1) DEFAULT NULL,
  PRIMARY KEY (`SCHED_NAME`,`ENTRY_ID`),
  KEY `IDX_QRTZ_FT_TRIG_INST_NAME` (`SCHED_NAME`,`INSTANCE_NAME`),
  KEY `IDX_QRTZ_FT_INST_JOB_REQ_RCVRY` (`SCHED_NAME`,`INSTANCE_NAME`,`REQUESTS_RECOVERY`),
  KEY `IDX_QRTZ_FT_J_G` (`SCHED_NAME`,`JOB_NAME`,`JOB_GROUP`),
  KEY `IDX_QRTZ_FT_JG` (`SCHED_NAME`,`JOB_GROUP`),
  KEY `IDX_QRTZ_FT_T_G` (`SCHED_NAME`,`TRIGGER_NAME`,`TRIGGER_GROUP`),
  KEY `IDX_QRTZ_FT_TG` (`SCHED_NAME`,`TRIGGER_GROUP`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

/*Data for the table `qrtz_fired_triggers` */

/*Table structure for table `qrtz_job_details` */

DROP TABLE IF EXISTS `qrtz_job_details`;

CREATE TABLE `qrtz_job_details` (
  `SCHED_NAME` varchar(120) NOT NULL,
  `JOB_NAME` varchar(120) NOT NULL,
  `JOB_GROUP` varchar(120) NOT NULL,
  `DESCRIPTION` varchar(250) DEFAULT 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,
  PRIMARY KEY (`SCHED_NAME`,`JOB_NAME`,`JOB_GROUP`),
  KEY `IDX_QRTZ_J_REQ_RECOVERY` (`SCHED_NAME`,`REQUESTS_RECOVERY`),
  KEY `IDX_QRTZ_J_GRP` (`SCHED_NAME`,`JOB_GROUP`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

/*Data for the table `qrtz_job_details` */

insert  into `qrtz_job_details`(`SCHED_NAME`,`JOB_NAME`,`JOB_GROUP`,`DESCRIPTION`,`JOB_CLASS_NAME`,`IS_DURABLE`,`IS_NONCONCURRENT`,`IS_UPDATE_DATA`,`REQUESTS_RECOVERY`,`JOB_DATA`) values ('schedulerFactoryBean','updateDialogStatusJobDetail','updateDialogStatusGroup',NULL,'com.winter.quartz.InvokingJobDetailDetailFactory','1','0','0','1','\0sr\0org.quartz.JobDataMap煱冭咯八\0\0xr\0&org.quartz.utils.StringKeyDirtyFlagMap?杳](\0Z\0allowsTransientDataxr\0org.quartz.utils.DirtyFlagMap??v\n?\0Z\0dirtyL\0mapt\0Ljava/util/Map;xpsr\0java.util.HashMap诹?`?\0F\0\nloadFactorI\0    thresholdxp?@\0\0\0\0\0w\0\0\0\0\0\0t\0targetObjectt\0    dialogJobt\0targetMethodt\0executex\0');

/*Table structure for table `qrtz_locks` */

DROP TABLE IF EXISTS `qrtz_locks`;

CREATE TABLE `qrtz_locks` (
  `SCHED_NAME` varchar(120) NOT NULL,
  `LOCK_NAME` varchar(40) NOT NULL,
  PRIMARY KEY (`SCHED_NAME`,`LOCK_NAME`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

/*Data for the table `qrtz_locks` */

insert  into `qrtz_locks`(`SCHED_NAME`,`LOCK_NAME`) values ('schedulerFactoryBean','STATE_ACCESS'),('schedulerFactoryBean','TRIGGER_ACCESS');

/*Table structure for table `qrtz_paused_trigger_grps` */

DROP TABLE IF EXISTS `qrtz_paused_trigger_grps`;

CREATE TABLE `qrtz_paused_trigger_grps` (
  `SCHED_NAME` varchar(120) NOT NULL,
  `TRIGGER_GROUP` varchar(120) NOT NULL,
  PRIMARY KEY (`SCHED_NAME`,`TRIGGER_GROUP`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

/*Data for the table `qrtz_paused_trigger_grps` */

/*Table structure for table `qrtz_scheduler_state` */

DROP TABLE IF EXISTS `qrtz_scheduler_state`;

CREATE TABLE `qrtz_scheduler_state` (
  `SCHED_NAME` varchar(120) NOT NULL,
  `INSTANCE_NAME` varchar(120) NOT NULL,
  `LAST_CHECKIN_TIME` bigint(13) NOT NULL,
  `CHECKIN_INTERVAL` bigint(13) NOT NULL,
  PRIMARY KEY (`SCHED_NAME`,`INSTANCE_NAME`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

/*Data for the table `qrtz_scheduler_state` */

insert  into `qrtz_scheduler_state`(`SCHED_NAME`,`INSTANCE_NAME`,`LAST_CHECKIN_TIME`,`CHECKIN_INTERVAL`) values ('schedulerFactoryBean','DESKTOP-OOOR8LP1536908627652',1536919659573,20000);

/*Table structure for table `qrtz_simple_triggers` */

DROP TABLE IF EXISTS `qrtz_simple_triggers`;

CREATE TABLE `qrtz_simple_triggers` (
  `SCHED_NAME` varchar(120) NOT NULL,
  `TRIGGER_NAME` varchar(120) NOT NULL,
  `TRIGGER_GROUP` varchar(120) 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`),
  CONSTRAINT `qrtz_simple_triggers_ibfk_1` FOREIGN KEY (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`) REFERENCES `qrtz_triggers` (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

/*Data for the table `qrtz_simple_triggers` */

/*Table structure for table `qrtz_simprop_triggers` */

DROP TABLE IF EXISTS `qrtz_simprop_triggers`;

CREATE TABLE `qrtz_simprop_triggers` (
  `SCHED_NAME` varchar(120) NOT NULL,
  `TRIGGER_NAME` varchar(120) NOT NULL,
  `TRIGGER_GROUP` varchar(120) NOT NULL,
  `STR_PROP_1` varchar(512) DEFAULT NULL,
  `STR_PROP_2` varchar(512) DEFAULT NULL,
  `STR_PROP_3` varchar(512) DEFAULT NULL,
  `INT_PROP_1` int(11) DEFAULT NULL,
  `INT_PROP_2` int(11) DEFAULT NULL,
  `LONG_PROP_1` bigint(20) DEFAULT NULL,
  `LONG_PROP_2` bigint(20) DEFAULT NULL,
  `DEC_PROP_1` decimal(13,4) DEFAULT NULL,
  `DEC_PROP_2` decimal(13,4) DEFAULT NULL,
  `BOOL_PROP_1` varchar(1) DEFAULT NULL,
  `BOOL_PROP_2` varchar(1) DEFAULT NULL,
  PRIMARY KEY (`SCHED_NAME`,`TRIGGER_NAME`,`TRIGGER_GROUP`),
  CONSTRAINT `qrtz_simprop_triggers_ibfk_1` FOREIGN KEY (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`) REFERENCES `qrtz_triggers` (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

/*Data for the table `qrtz_simprop_triggers` */

/*Table structure for table `qrtz_triggers` */

DROP TABLE IF EXISTS `qrtz_triggers`;

CREATE TABLE `qrtz_triggers` (
  `SCHED_NAME` varchar(120) NOT NULL,
  `TRIGGER_NAME` varchar(120) NOT NULL,
  `TRIGGER_GROUP` varchar(120) NOT NULL,
  `JOB_NAME` varchar(120) NOT NULL,
  `JOB_GROUP` varchar(120) NOT NULL,
  `DESCRIPTION` varchar(250) DEFAULT NULL,
  `NEXT_FIRE_TIME` bigint(13) DEFAULT NULL,
  `PREV_FIRE_TIME` bigint(13) DEFAULT NULL,
  `PRIORITY` int(11) DEFAULT NULL,
  `TRIGGER_STATE` varchar(16) NOT NULL,
  `TRIGGER_TYPE` varchar(8) NOT NULL,
  `START_TIME` bigint(13) NOT NULL,
  `END_TIME` bigint(13) DEFAULT NULL,
  `CALENDAR_NAME` varchar(200) DEFAULT NULL,
  `MISFIRE_INSTR` smallint(2) DEFAULT NULL,
  `JOB_DATA` blob,
  PRIMARY KEY (`SCHED_NAME`,`TRIGGER_NAME`,`TRIGGER_GROUP`),
  KEY `IDX_QRTZ_T_J` (`SCHED_NAME`,`JOB_NAME`,`JOB_GROUP`),
  KEY `IDX_QRTZ_T_JG` (`SCHED_NAME`,`JOB_GROUP`),
  KEY `IDX_QRTZ_T_C` (`SCHED_NAME`,`CALENDAR_NAME`(191)),
  KEY `IDX_QRTZ_T_G` (`SCHED_NAME`,`TRIGGER_GROUP`),
  KEY `IDX_QRTZ_T_STATE` (`SCHED_NAME`,`TRIGGER_STATE`),
  KEY `IDX_QRTZ_T_N_STATE` (`SCHED_NAME`,`TRIGGER_NAME`,`TRIGGER_GROUP`,`TRIGGER_STATE`),
  KEY `IDX_QRTZ_T_N_G_STATE` (`SCHED_NAME`,`TRIGGER_GROUP`,`TRIGGER_STATE`),
  KEY `IDX_QRTZ_T_NEXT_FIRE_TIME` (`SCHED_NAME`,`NEXT_FIRE_TIME`),
  KEY `IDX_QRTZ_T_NFT_ST` (`SCHED_NAME`,`TRIGGER_STATE`,`NEXT_FIRE_TIME`),
  KEY `IDX_QRTZ_T_NFT_MISFIRE` (`SCHED_NAME`,`MISFIRE_INSTR`,`NEXT_FIRE_TIME`),
  KEY `IDX_QRTZ_T_NFT_ST_MISFIRE` (`SCHED_NAME`,`MISFIRE_INSTR`,`NEXT_FIRE_TIME`,`TRIGGER_STATE`),
  KEY `IDX_QRTZ_T_NFT_ST_MISFIRE_GRP` (`SCHED_NAME`,`MISFIRE_INSTR`,`NEXT_FIRE_TIME`,`TRIGGER_GROUP`,`TRIGGER_STATE`),
  CONSTRAINT `qrtz_triggers_ibfk_1` FOREIGN KEY (`SCHED_NAME`, `JOB_NAME`, `JOB_GROUP`) REFERENCES `qrtz_job_details` (`SCHED_NAME`, `JOB_NAME`, `JOB_GROUP`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

/*Data for the table `qrtz_triggers` */

insert  into `qrtz_triggers`(`SCHED_NAME`,`TRIGGER_NAME`,`TRIGGER_GROUP`,`JOB_NAME`,`JOB_GROUP`,`DESCRIPTION`,`NEXT_FIRE_TIME`,`PREV_FIRE_TIME`,`PRIORITY`,`TRIGGER_STATE`,`TRIGGER_TYPE`,`START_TIME`,`END_TIME`,`CALENDAR_NAME`,`MISFIRE_INSTR`,`JOB_DATA`) values ('schedulerFactoryBean','dialogJobTrigger','DEFAULT','updateDialogStatusJobDetail','updateDialogStatusGroup',NULL,1536919680000,1536919620000,0,'WAITING','CRON',1536908627000,0,NULL,0,'');

 

 

 

july_young
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spring boot quartz集群实现
06-13
一个基于springboot的quartz集群dome。 向http://localhost:9090/job/addjob注入3个参数 类名：（及时定时任务的类如：com.ybjdw.site.job.NewJob） 组名：随意 定时启动方法：如“0/3 * * * * ?”（每3秒启动一次） quartz会这这些数据存入数据库中，形成一个任务项。 之后的服务器会根据数据库中的内容启动定时任务。 因为定时任务是根据数据库内任务状态启动的所以避免了并发重复的显现。 本项目没有接入多个节点所以支持集群却没有真正实现，否则不好启动。
springboot 集成 quartz 集群 加 sql 等
03-13
springboot 集成 quartz 集群 加 sql 等 文章介绍 单机加集群都有 https://blog.csdn.net/weixin_42749765/article/details/88532413
springboot整合quartz(集群环境)
热门推荐
Button的博客
09-24 3万+
quartz
Springboot--整合定时任务quartz--集群篇
最新发布
拽着尾巴的鱼儿的博客
02-23 2321
通常在生产环境中，不会存在单体的应用，如一个订单服务，可能同时部署多个相同的服务到不同的服务上，从而形成集群。此时定时任务就会面临重复执行的问题；@Autowired@Bean// 标识quartz 数据源quartz 的集群需要同一个服务的不同实例，都要连接到同一个 定时任务的数据源，并且通过 org.quartz.jobStore.isClustered: true 开启 集群，以实现定时任务的负载均衡和故障转移。
SpringBoot 整合Quartz（集群）实现定时任务调度
02-14
1、若是部署多台机器，到了时间点，只有一台会执行，其他不会执行。 2、若多个节点其中一个scheduler执行job失败，将会被另外一个scheduler执行
spring boot + quartz集群搭建的完整步骤
08-27
Spring Boot + Quartz 集群搭建的完整步骤 Spring Boot 是一个流行的 Java 框架，用于快速构建基于 Spring 的应用程序。Quartz 是一个流行的开源作业调度框架，可以用于实现定时任务的调度。 Spring Boot + Quartz ...
spring boot + quartz 动态管理 分布式
08-29
在IT行业中，Spring Boot和Quartz是两个非常重要的框架，它们在企业级应用开发中扮演着关键角色。Spring Boot简化了Spring应用的初始搭建以及开发过程，提供了开箱即用的功能，而Quartz则是一个强大的任务调度库，常...
springboot整合quartz定时任务yml文件配置方式
03-23
在Spring Boot应用中整合Quartz定时任务是一种常见的需求，它可以帮助我们执行周期性的后台任务，如数据同步、报表生成等。Spring Boot与Quartz的结合提供了便捷的配置方式，特别是通过YAML（YAML Ain't Markup ...
spring boot集成quartz定时器
01-23
1. 添加依赖：首先，你需要在Spring Boot项目的`pom.xml`或`build.gradle`文件中添加Quartz和Spring Boot对Quartz的支持。如果是Maven项目，添加以下依赖： ```xml <groupId>org.springframework.boot ...
Springboot集成quartz集群
09-29
本文章是关于springboot集成quartz集群的步骤，LZ亲测。
SpringBoot集成Quartz集群模式
u014644574的博客
07-09 1505
SpringBoot集成Quartz集群模式
SpringBoot 整合Quartz实现分布式集群定时任务
m0_55876338的博客
06-13 198
SpringBoot 整合Quartz实现分布式集群定时任务 (icode9.com)
spring boot + quartz 集群
zhldt2008的专栏
07-20 392
spring boot bean配置： 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...
SpringBoot整合QuartZ
zy1104560031的专栏
03-11 393
quartz是一个基于java的非常成熟的任务调度框架，适合于任何常规的使用，以及个性化的开发使用， 其次通过数据库的持久化，可以选择实现集群，大大增加了任务调度的可靠性。 工作时候会在这些情况下使用到quartz框架： 餐厅系统会在每周四晚上的22点自动审核并生成报表 人事系统会在每天早晨8点给有待办的人员自动发送Email提醒 1、创建调度工厂(); 　　//工厂模式...
【后端-Quartz】Springboot整合Quartz支持集群环境-设计业务与框架分离及实现定时任务调度
Ric的博客
03-22 3845
目录背景使用quartz总结 背景 我们的各个服务需要改造支持集群，现在的授权、日程使用的是基于内存的spring scheduler定时任务，如果部署多个节点，那么到了时间点，多个节点都会开始执行定时任务从而可能引起业务和性能上的问题。 服务中的定时任务比较轻量，为了避免引入redis、zookeeper、单独的定时任务程序，所以建议选用quartz这种基于数据库的分布式定时任务调度框架，无需引用多余中间件。 使用quartz 在官网下载quartz 下载之后解压，进入src\org\quart
SpringBoot 快速整合 QuartZ
yiqiu1959的博客
08-11 915
前言 Quartz是OpenSymphony开源组织在Job scheduling领域又一个开源项目，完全由Java开发，可以用来执行定时任务，类似于java.util.Timer。但是相较于Timer， Quartz增加了很多功能： 持久性作业 - 就是保持调度定时的状态; 作业管理 - 对调度作业进行有效的管理; 架构图和知识点 1、引入QuartZ依赖 SpringBoot的依赖自行获取，这里不予提供 <!-- quartz 依赖 没有规定版本的 可以用2.3.0-->
Springboot开启Quartz集群
stone5751的专栏
12-05 368
quartz
SpringBoot整合Quartz实现分布式集群定时任务
Be yourself,everyone else is already taken
07-04 661
java定时器
springboot 整合quartz详解
疯狂的蜗牛
10-24 4905
本文主要是针对springboot 整合quartz 来说明，作为一个小白我总喜欢上网查找资料，然后希望找的东西能80%符合自己的需求，能直接拿来用的，但是很多时候网上的案例都是一个copy一个的，看的东西千篇一律，而且有些内容解释的也是寥寥数语，所以有时候也需要自己写点东西分享给大众，今天也是自己刚申请csdn ,取的笔名为：随笔发烧友，励志自己后面能多写文章，乐在分享。好了，进入正题吧！ ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值