SpringBoot集成Quartz

最新推荐文章于 2024-06-03 10:27:17 发布
最新推荐文章于 2024-06-03 10:27:17 发布
阅读量1.3k 收藏 1
点赞数 1
分类专栏： 项目技术点
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Yuwen110/article/details/118832914
版权

目录

目的：订单  --》Quartz / 延迟队列 / 前端定时器

一、Quartz

 业务中使用Quartz

实现步骤：

1、提供一个接口，里面有两个方法，并实现

2、QuartzJobInfo接收传入的参数，相当于domain

3、QuartzUtils 工具类，封装起来可以实现动态的添加删除任务

4、MainJob抽取出来的业务实现类

目的：订单  --》Quartz / 延迟队列 / 前端定时器

1、订单未支付倒计时取消 （支付超时）

2、支付之后收获的待确认 （自动确认）  ---- 收了货不确认，平台就不会把钱打给

总共4类型订单

1、领养

2、服务

3、goods

4、充值   特殊：充值后不会退钱

一、Quartz

quartz工作原理

看不懂了再回看一下详情

 Cron表达式，或者直接根据下面的方法，给一个日期转换成Cron表达式。

 /**
     * 将日期转换为cron表达式
     * @param fireDate
     */
    public void setFireDate(Date fireDate) {
        this.fireDate = fireDate;
        String[] cronArr = new String[7];
        for (int i = 0; i < cronArr.length; i++) {
            cronArr[i] = "";
        }
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(fireDate);
        int second = calendar.get(Calendar.SECOND);
        int minute = calendar.get(Calendar.MINUTE);
        int hour = calendar.get(Calendar.HOUR_OF_DAY);
        int day = calendar.get(Calendar.DAY_OF_MONTH);
        int month = calendar.get(Calendar.MONTH) + 1;
        int year = calendar.get(Calendar.YEAR);

        cronArr[0] = second + "";
        cronArr[1] = minute + "";
        cronArr[2] = hour + "";

        cronArr[3] = day + "";
        cronArr[4] = month + "";
        cronArr[5] = "?";
        cronArr[6] = year + "";

        String cron = String.join(" ", cronArr);
        this.setCronj(cron);
    }
简单实现Quartz
1、导入依赖
<!--定时器-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-quartz</artifactId>
</dependency>

2、配置类中要将JobDetail+Trigger  一起绑定给scheduler

@Configuration
public class QuartzConfig {
   @Bean
    public JobDetail newJob(){
        return JobBuilder.newJob(PrintTimeJob.class)//PrintTimeJob我们的业务类
                .withIdentity("9527")//可以给该JobDetail起一个id
                //每个JobDetail内都有一个Map，包含了关联到这个Job的数据，在Job类中可以通过context获取
                .usingJobData("msg", "Hello Quartz")//关联键值对
                .storeDurably()//即使没有Trigger关联时，也不需要删除该JobDetail
                .build();
    }
    @Bean
    public Trigger printTimeJobTrigger() {
        CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule("0/1 * * * * ? ");
        return TriggerBuilder.newTrigger()
                .forJob(newJob())//关联上述的JobDetail
                .withIdentity("quartzTaskService")//给Trigger起个名字
                .withSchedule(cronScheduleBuilder)
                .build();
    }
}

 3、具体的任务job   

4、启动springboot  配置类会自动运行 定时器

可以在上面的基础上引入双数据源，因为quartz要持久化，所以把数据存到另一个数据库quartz中

1、application.yaml中加

spring:
  datasource:
    #双数据源之pethome
    driver-class-name: com.mysql.jdbc.Driver
    jdbcUrl: jdbc:mysql:///pethome
    username: root
    password: root
 

  quartz:
    job-store-type: jdbc #持久化到数据库
    properties:
      org:
        quartz:
          #双数据源之quartz
          datasource:
            driver-class-name: com.mysql.jdbc.Driver
            jdbcUrl: jdbc:mysql:///quartz?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC
            username: root
            password: root
          scheduler:
            instancName: clusteredScheduler
            instanceId: AUTO
          jobStore:
            class: org.quartz.impl.jdbcjobstore.JobStoreTX
            driverDelegateClass: org.quartz.impl.jdbcjobstore.StdJDBCDelegate #StdJDBCDelegate说明支持集群
            tablePrefix: QRTZ_
            isClustered: true
            clusterCheckinInterval: 1000
            useProperties: false
          threadPool:
            class: org.quartz.simpl.SimpleThreadPool
            threadCount: 20
            threadPriority: 5

2、写一个配置类 ，把两个数据源使用起来

import org.springframework.boot.autoconfigure.quartz.QuartzDataSource;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.jdbc.DataSourceBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;

import javax.sql.DataSource;

/**
 * 配置数据源
 */
@Configuration
public class QuartzConfig {

    //主数据源
    @Bean
    @Primary //主数据库，指向pethome
    @ConfigurationProperties(prefix = "spring.datasource")
    DataSource dataSource(){
        return DataSourceBuilder.create().build();
    }

    //为quartz创建一个自己数据源
    @Bean
    @QuartzDataSource //quartz数据源
    @ConfigurationProperties(prefix = "spring.quartz.properties.org.quartz.datasource")
    DataSource quartzDataSource(){
        return DataSourceBuilder.create().build();
    }
}

准备quartz库

sql文件内容

#
# In your Quartz properties file, you'll need to set
# org.quartz.jobStore.driverDelegateClass = org.quartz.impl.jdbcjobstore.StdJDBCDelegate
#
#
# By: Ron Cordell - roncordell
#  I didn't see this anywhere, so I thought I'd post it here. This is the script from Quartz to create the tables in a MySQL database, modified to use INNODB instead of MYISAM.

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(190) NOT NULL,
JOB_GROUP VARCHAR(190) 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))
ENGINE=InnoDB;

CREATE TABLE QRTZ_TRIGGERS (
SCHED_NAME VARCHAR(120) NOT NULL,
TRIGGER_NAME VARCHAR(190) NOT NULL,
TRIGGER_GROUP VARCHAR(190) NOT NULL,
JOB_NAME VARCHAR(190) NOT NULL,
JOB_GROUP VARCHAR(190) 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(190) 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))
ENGINE=InnoDB;

CREATE TABLE QRTZ_SIMPLE_TRIGGERS (
SCHED_NAME VARCHAR(120) NOT NULL,
TRIGGER_NAME VARCHAR(190) NOT NULL,
TRIGGER_GROUP VARCHAR(190) 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))
ENGINE=InnoDB;

CREATE TABLE QRTZ_CRON_TRIGGERS (
SCHED_NAME VARCHAR(120) NOT NULL,
TRIGGER_NAME VARCHAR(190) NOT NULL,
TRIGGER_GROUP VARCHAR(190) NOT NULL,
CRON_EXPRESSION VARCHAR(120) 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))
ENGINE=InnoDB;

CREATE TABLE QRTZ_SIMPROP_TRIGGERS
  (
    SCHED_NAME VARCHAR(120) NOT NULL,
    TRIGGER_NAME VARCHAR(190) NOT NULL,
    TRIGGER_GROUP VARCHAR(190) 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))
ENGINE=InnoDB;

CREATE TABLE QRTZ_BLOB_TRIGGERS (
SCHED_NAME VARCHAR(120) NOT NULL,
TRIGGER_NAME VARCHAR(190) NOT NULL,
TRIGGER_GROUP VARCHAR(190) NOT NULL,
BLOB_DATA BLOB NULL,
PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
INDEX (SCHED_NAME,TRIGGER_NAME, TRIGGER_GROUP),
FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP))
ENGINE=InnoDB;

CREATE TABLE QRTZ_CALENDARS (
SCHED_NAME VARCHAR(120) NOT NULL,
CALENDAR_NAME VARCHAR(190) NOT NULL,
CALENDAR BLOB NOT NULL,
PRIMARY KEY (SCHED_NAME,CALENDAR_NAME))
ENGINE=InnoDB;

CREATE TABLE QRTZ_PAUSED_TRIGGER_GRPS (
SCHED_NAME VARCHAR(120) NOT NULL,
TRIGGER_GROUP VARCHAR(190) NOT NULL,
PRIMARY KEY (SCHED_NAME,TRIGGER_GROUP))
ENGINE=InnoDB;

CREATE TABLE QRTZ_FIRED_TRIGGERS (
SCHED_NAME VARCHAR(120) NOT NULL,
ENTRY_ID VARCHAR(95) NOT NULL,
TRIGGER_NAME VARCHAR(190) NOT NULL,
TRIGGER_GROUP VARCHAR(190) NOT NULL,
INSTANCE_NAME VARCHAR(190) 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(190) NULL,
JOB_GROUP VARCHAR(190) NULL,
IS_NONCONCURRENT VARCHAR(1) NULL,
REQUESTS_RECOVERY VARCHAR(1) NULL,
PRIMARY KEY (SCHED_NAME,ENTRY_ID))
ENGINE=InnoDB;

CREATE TABLE QRTZ_SCHEDULER_STATE (
SCHED_NAME VARCHAR(120) NOT NULL,
INSTANCE_NAME VARCHAR(190) NOT NULL,
LAST_CHECKIN_TIME BIGINT(13) NOT NULL,
CHECKIN_INTERVAL BIGINT(13) NOT NULL,
PRIMARY KEY (SCHED_NAME,INSTANCE_NAME))
ENGINE=InnoDB;

CREATE TABLE QRTZ_LOCKS (
SCHED_NAME VARCHAR(120) NOT NULL,
LOCK_NAME VARCHAR(40) NOT NULL,
PRIMARY KEY (SCHED_NAME,LOCK_NAME))
ENGINE=InnoDB;

CREATE INDEX IDX_QRTZ_J_REQ_RECOVERY ON QRTZ_JOB_DETAILS(SCHED_NAME,REQUESTS_RECOVERY);
CREATE INDEX IDX_QRTZ_J_GRP ON QRTZ_JOB_DETAILS(SCHED_NAME,JOB_GROUP);

CREATE INDEX IDX_QRTZ_T_J ON QRTZ_TRIGGERS(SCHED_NAME,JOB_NAME,JOB_GROUP);
CREATE INDEX IDX_QRTZ_T_JG ON QRTZ_TRIGGERS(SCHED_NAME,JOB_GROUP);
CREATE INDEX IDX_QRTZ_T_C ON QRTZ_TRIGGERS(SCHED_NAME,CALENDAR_NAME);
CREATE INDEX IDX_QRTZ_T_G ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_GROUP);
CREATE INDEX IDX_QRTZ_T_STATE ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_STATE);
CREATE INDEX IDX_QRTZ_T_N_STATE ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP,TRIGGER_STATE);
CREATE INDEX IDX_QRTZ_T_N_G_STATE ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_GROUP,TRIGGER_STATE);
CREATE INDEX IDX_QRTZ_T_NEXT_FIRE_TIME ON QRTZ_TRIGGERS(SCHED_NAME,NEXT_FIRE_TIME);
CREATE INDEX IDX_QRTZ_T_NFT_ST ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_STATE,NEXT_FIRE_TIME);
CREATE INDEX IDX_QRTZ_T_NFT_MISFIRE ON QRTZ_TRIGGERS(SCHED_NAME,MISFIRE_INSTR,NEXT_FIRE_TIME);
CREATE INDEX IDX_QRTZ_T_NFT_ST_MISFIRE ON QRTZ_TRIGGERS(SCHED_NAME,MISFIRE_INSTR,NEXT_FIRE_TIME,TRIGGER_STATE);
CREATE INDEX IDX_QRTZ_T_NFT_ST_MISFIRE_GRP ON QRTZ_TRIGGERS(SCHED_NAME,MISFIRE_INSTR,NEXT_FIRE_TIME,TRIGGER_GROUP,TRIGGER_STATE);

CREATE INDEX IDX_QRTZ_FT_TRIG_INST_NAME ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,INSTANCE_NAME);
CREATE INDEX IDX_QRTZ_FT_INST_JOB_REQ_RCVRY ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,INSTANCE_NAME,REQUESTS_RECOVERY);
CREATE INDEX IDX_QRTZ_FT_J_G ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,JOB_NAME,JOB_GROUP);
CREATE INDEX IDX_QRTZ_FT_JG ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,JOB_GROUP);
CREATE INDEX IDX_QRTZ_FT_T_G ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP);
CREATE INDEX IDX_QRTZ_FT_TG ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,TRIGGER_GROUP);

commit;

 业务中使用Quartz

 

 不管是领养订单还是其他订单，都会涉及到两个环节：

1、订单超时未支付自动取消

2、收到货以后没有点确认

实现步骤：

1、提供一个接口，里面有两个方法，并实现

import cn.shenmo.quartz.jobs.MainJob;
import cn.shenmo.quartz.service.IquartzService;
import cn.shenmo.quartz.util.QuartzJobInfo;
import cn.shenmo.quartz.util.QuartzUtils;
import org.quartz.Scheduler;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;
import org.springframework.stereotype.Service;

@Service
public class QuartzServiceImpl implements IquartzService {

    //使用工厂去获取scheduler调度器
    @Autowired
    private SchedulerFactoryBean schedulerFactoryBean;

    //动态添加任务
    @Override
    public void addJob(QuartzJobInfo info) {
        //保证参数不为空
        if(info != null){
            //引入quartz的包之后，通过工厂获取调度器
            Scheduler scheduler = schedulerFactoryBean.getScheduler();
            //获取job名
            String jobName=info.getJobName();
            //动态加入任务需要传入抽取出来的任务类.class
            Class cls = MainJob.class;
            //特别：没有直接传相应的type而是整个传，是因为，mainJob中还要判断参数type，怕拿不到
            Object params = info;
            String cron = info.getCronj();
            //添加定时任务
            QuartzUtils.addJob(scheduler, jobName, cls, params, cron);
            System.out.println("添加"+jobName+"定时任务成功！");
        }
    }

    //动态删除任务
    @Override
    public void removeJob(String jobName) {
        Scheduler scheduler = schedulerFactoryBean.getScheduler();
        //删除定时任务
        QuartzUtils.removeJob(scheduler,jobName );
        System.out.println("删除"+jobName+"定时任务成功！");
    }
}

2、QuartzJobInfo接收传入的参数，相当于domain

/**
 * 动态定时操作时候，需要传入一些参数，此类为domain 接收传来的参数
 */
@Data
public class QuartzJobInfo implements Serializable {
    private String type;
    private String jobName;
    private Map<String, Object> params;
    private String cronj;
    private Date fireDate;

    /**
     * 将日期转换为cron表达式
     * @param fireDate
     */
    public void setFireDate(Date fireDate) {
        this.fireDate = fireDate;
        String[] cronArr = new String[7];
        for (int i = 0; i < cronArr.length; i++) {
            cronArr[i] = "";
        }
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(fireDate);
        int second = calendar.get(Calendar.SECOND);
        int minute = calendar.get(Calendar.MINUTE);
        int hour = calendar.get(Calendar.HOUR_OF_DAY);
        int day = calendar.get(Calendar.DAY_OF_MONTH);
        int month = calendar.get(Calendar.MONTH) + 1;
        int year = calendar.get(Calendar.YEAR);

        cronArr[0] = second + "";
        cronArr[1] = minute + "";
        cronArr[2] = hour + "";

        cronArr[3] = day + "";
        cronArr[4] = month + "";
        cronArr[5] = "?";
        cronArr[6] = year + "";

        String cron = String.join(" ", cronArr);
        this.setCronj(cron);
    }

}

3、QuartzUtils 工具类，封装起来可以实现动态的添加删除任务


/**
 * Quartz调度管理器  Quartz工具类，动态添加删除 任务就使用这个工具类
 * 
 */
public class QuartzUtils {
   private static String JOB_GROUP_NAME = "JOB_GROUP_SYSTEM";
   private static String TRIGGER_GROUP_NAME = "TRIGGER_GROUP_SYSTEM";

   /**
    * @Description: 添加一个定时任务，使用默认的任务组名，触发器名，触发器组名
    * 
    * @param sched
    *            调度器
    * 
    * @param jobName
    *            任务名
    * @param cls
    *            任务
    * @param params
    *            任务参数
    * @param time
    *            时间设置，参考quartz说明文档
    * 
    * @Title: QuartzManager.java
    */
   public static void addJob(Scheduler sched, String jobName, @SuppressWarnings("rawtypes") Class cls, Object params,
                             String time) {
      try {
         JobKey jobKey = new JobKey(jobName, JOB_GROUP_NAME);// 任务名，任务组，任务执行类
         @SuppressWarnings("unchecked")

         JobDataMap jobDataMap = new JobDataMap();
         jobDataMap.put("params", params);
         JobDetail jobDetail = newJob(cls).withIdentity(jobKey).setJobData(jobDataMap).build();
         TriggerKey triggerKey = new TriggerKey(jobName, TRIGGER_GROUP_NAME);// 触发器
         System.out.println(time);
         Trigger trigger = newTrigger().withIdentity(triggerKey).withSchedule(cronSchedule(time)).build();// 触发器时间设定
         sched.scheduleJob(jobDetail, trigger);
         if (!sched.isShutdown()) {
            sched.start();// 启动
         }
      } catch (Exception e) {
         throw new RuntimeException(e);
      }
   }

   /**
    * @Description: 添加一个定时任务
    * 
    * @param sched
    *            调度器
    * 
    * @param jobName
    *            任务名
    * @param jobGroupName
    *            任务组名
    * @param triggerName
    *            触发器名
    * @param triggerGroupName
    *            触发器组名
    * @param jobClass
    *            任务
    * @param params
    *            任务参数
    * @param time
    *            时间设置，参考quartz说明文档
    * 
    * @Title: QuartzManager.java
    */
   public static void addJob(Scheduler sched, String jobName, String jobGroupName, String triggerName,
                             String triggerGroupName, @SuppressWarnings("rawtypes") Class jobClass, Object params, String time) {
      try {
         JobKey jobKey = new JobKey(jobName, jobGroupName);
         JobDataMap jobDataMap = new JobDataMap();
         jobDataMap.put("params", params);
         @SuppressWarnings("unchecked")
         JobDetail jobDetail = newJob(jobClass).withIdentity(jobKey).setJobData(jobDataMap).build();
         // 触发器
         TriggerKey triggerKey = new TriggerKey(triggerName, triggerGroupName);
         Trigger trigger = newTrigger().withIdentity(triggerKey).withSchedule(cronSchedule(time)).build();
         sched.scheduleJob(jobDetail, trigger);
      } catch (Exception e) {
         throw new RuntimeException(e);
      }
   }

   /**
    * @Description: 修改一个任务的触发时间(使用默认的任务组名，触发器名，触发器组名)
    * 
    * @param sched
    *            调度器
    * @param jobName
    * @param time
    * 
    * @Title: QuartzManager.java
    */
   @SuppressWarnings("rawtypes")
   public static void modifyJobTime(Scheduler sched, String jobName, String time) {
      try {
         TriggerKey triggerKey = new TriggerKey(jobName, TRIGGER_GROUP_NAME);
         CronTrigger trigger = (CronTrigger) sched.getTrigger(triggerKey);
         if (trigger == null) {
            return;
         }
         String oldTime = trigger.getCronExpression();
         if (!oldTime.equalsIgnoreCase(time)) {
            JobKey jobKey = new JobKey(jobName, JOB_GROUP_NAME);
            JobDetail jobDetail = sched.getJobDetail(jobKey);
            Class objJobClass = jobDetail.getJobClass();
            Object params = jobDetail.getJobDataMap().get("params");
            removeJob(sched, jobName);
            System.out.println("修改任务：" + jobName);
            addJob(sched, jobName, objJobClass, params,time);
         }
      } catch (Exception e) {
         throw new RuntimeException(e);
      }
   }

   /**
    * @Description: 修改一个任务的触发时间
    * 
    * @param sched
    *            调度器 *
    * @param sched
    *            调度器
    * @param triggerName
    * @param triggerGroupName
    * @param time
    * 
    * @Title: QuartzManager.java
    */
   public static void modifyJobTime(Scheduler sched, String triggerName, String triggerGroupName, String time) {
      try {
         TriggerKey triggerKey = new TriggerKey(triggerName, triggerGroupName);
         CronTrigger trigger = (CronTrigger) sched.getTrigger(triggerKey);
         if (trigger == null) {
            return;
         }
         String oldTime = trigger.getCronExpression();
         if (!oldTime.equalsIgnoreCase(time)) {
            // 修改时间
            trigger.getTriggerBuilder().withSchedule(cronSchedule(time));
            // 重启触发器
            sched.resumeTrigger(triggerKey);
         }
      } catch (Exception e) {
         throw new RuntimeException(e);
      }
   }

   /**
    * @Description: 移除一个任务(使用默认的任务组名，触发器名，触发器组名)
    * 
    * @param sched
    *            调度器
    * @param jobName
    * 
    * @Title: QuartzManager.java
    */
   public static void removeJob(Scheduler sched, String jobName) {
      try {
         TriggerKey triggerKey = new TriggerKey(jobName, TRIGGER_GROUP_NAME);
         sched.pauseTrigger(triggerKey);// 停止触发器
         sched.unscheduleJob(triggerKey);// 移除触发器
         JobKey jobKey = new JobKey(jobName, JOB_GROUP_NAME);
         sched.deleteJob(jobKey);// 删除任务
      } catch (Exception e) {
         throw new RuntimeException(e);
      }
   }

   /**
    * @Description: 移除一个任务
    * 
    * @param sched
    *            调度器
    * @param jobName
    * @param jobGroupName
    * @param triggerName
    * @param triggerGroupName
    * 
    * @Title: QuartzManager.java
    */
   public static void removeJob(Scheduler sched, String jobName, String jobGroupName, String triggerName,
                                String triggerGroupName) {
      try {
         TriggerKey triggerKey = new TriggerKey(triggerName, triggerGroupName);
         sched.pauseTrigger(triggerKey);// 停止触发器
         sched.unscheduleJob(triggerKey);// 移除触发器
         JobKey jobKey = new JobKey(jobName, jobGroupName);
         sched.deleteJob(jobKey);// 删除任务
      } catch (Exception e) {
         throw new RuntimeException(e);
      }
   }

   /**
    * @Description:启动所有定时任务
    * 
    * @param sched  调度器
    * 
    * @Title: QuartzManager.java
    */
   public static void startJobs(Scheduler sched) {
      try {
         sched.start();
      } catch (Exception e) {
         throw new RuntimeException(e);
      }
   }

   /**
    * @Description:关闭所有定时任务
    * 
    * @param sched
    *            调度器
    * 
    */
   public static void shutdownJobs(Scheduler sched) {
      try {
         if (!sched.isShutdown()) {
            sched.shutdown();
         }
      } catch (Exception e) {
         throw new RuntimeException(e);
      }
   }
}

4、MainJob抽取出来的业务实现类


/**
 * 公共业务实现类,领养订单、服务订单、充值订单、goods订单....
 *  每种订单，都可以动态调用 quartz的 add  remove
 */

public class MainJob implements Job {
    @Autowired
    private IAdoptOrderService adoptOrderService;

    /**
     * 满足指定的时间后，会触发这里执行业务逻辑
     *   取消订单
     *   订单自动确认
     * @param context
     * @throws JobExecutionException
     */
    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        System.out.println("触发执行定时任务业务。。。。");
        QuartzJobInfo info = (QuartzJobInfo) context.getJobDetail().getJobDataMap().get("params");
        Map<String, Object> params = info.getParams();
        if(JobConstants.ADOPT_ORDER_AUTO_CANCEL.equals(info.getType())){//领养订单超时取消
            Long orderId = Long.valueOf(params.get("orderId").toString());
            AdoptOrder adoptOrder = adoptOrderService.queryById(orderId);
            adoptOrder.setState(-1);
            adoptOrderService.update(adoptOrder);

        }else if(JobConstants.ADOPT_ORDER_AUTO_CONFIRM.equals(info.getType())){//领养订单超时自动确认

        }
        //服务订单超时取消

    }
}

二、RabbitMq暂时不讲

rabbitmq工作原理

三、前端定时器

凌洲
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Springboot 整合Quartz
yang_fei9264的博客
07-04 6805
springboot整合quartz相关基本配置
SpringBoot整合Quartz
weixin_44222066的博客
01-05 260
SpringBoot整合Quartz 首先我们要知道我们整合Quartz需要哪些步骤 1、首先我们需要进入Quartz官网，下载我们使用需要的内置表sql 官网：http://www.quartz-scheduler.org/ 下载下来是一个完整的文件夹，我们需要进入docs–>dbTables，然后在里面找你需要的数据类型的sql，然后把sql文件导入你的数据库 它里面有11张表，这些表...
quartz 2.x 定时任务创建，修改，删除，执行的工具类
猎人在吃肉
02-09 1179
import com.google.gson.Gson; import com.aop8.common.exception.ServerException; import com.aop8.common.utils.Constant.ScheduleStatus; import com.aop8.modules.admin.job.entity.ScheduleJobEntity; import...
Spring Boot 集成 Quartz（任务调度框架）
欲变世界，先变其身
09-28 5508
Quartz 是完全由Java开发的作业调度框架，当定时任务愈加复杂时，使用Spring注解@Schedule已经不能满足业务需要。} }return JobBuilder . newJob(SampleJob . class) . withIdentity("job" , "group") . withDescription("任务描述：内存方式运行") . storeDurably() . build();} }
4-Quartz与Spring Boot的集成
最新发布
qq_35752835的博客
06-03 620
Quartz是OpenSymphony开源组织在Job scheduling领域又一个开源项目，完全由Java开发，可以用来执行定时任务，类似于java.util.Timer。负责执行相关任务触发器Trigger负责指定相关Job的执行时间，执行间隔，运行次数负责将将指定的触发器应用到指定的任务中
springboot集成quartz
学海无涯,我用JAVA
06-14 3456
引用上一篇博客的说法springboot整合xxl-job,集群模式下,定时任务会造成很严重的事故,其次普通的任务也无法做到像xxl-job与Quartz 一样,及时启停,修改等;上一篇介绍了xxl-job,这篇搞一下Quartz,老牌分布式定时任务了;基本实现了任务的动态添加有参数的具体任务调用,修改QuartzJob中的方法获取,参数获取等,但是依旧采用代理实现任务并发执行未处理,后续完善项目地址。
Spring Boot 集成Quartz
qq_19891197的博客
02-05 4799
Spring Boot 集成Quartz
SpringBoot（二）集成 Quartz
SpringHASh的博客
10-21 2821
Quartz是一个广泛使用的开源任务调度框架，用于在Java应用程序中执行定时任务和周期性任务。它提供了强大的调度功能，允许您计划、管理和执行各种任务，从简单的任务到复杂的任务。
Springboot集成quartz集群
09-29
本文章是关于springboot集成quartz集群的步骤，LZ亲测。
springboot 集成quartz
12-27
亲测可用，springboot整合quartz。包含2个核心类QuartzConfiguration类和JobFactory类，修改数据库连接application和quartz.properties直接运行，访问http://localhost:8080/index。
SpringBoot集成Quartz分布式定时任务
11-01
1. **SpringBoot集成Quartz**： 在SpringBoot项目中集成Quartz，首先需要在`pom.xml`文件中添加Quartz和SpringBoot对Quartz的支持依赖。例如： ```xml <groupId>org.springframework.boot <artifactId>spring-...
SpringBoot集成Quartz实现定时任务的方法
08-19
3. **SpringBoot集成Quartz**： SpringBoot提供了`spring-boot-starter-quartz`模块，简化了Quartz的集成过程。一旦检测到Quartz库，SpringBoot会自动配置Scheduler。SpringBoot会自动收集并关联Scheduler上的...
quartz:SpringBoot 集成 Quartz 实现可控的任务
04-28
SpringBoot 集成 Quartz 实现可控的任务 建立数据库，运行脚本，数据库sql脚本位于 quartz\src\main\resources\schema\schema-mysql.sql。 修改Spring boot配置文件相应的数据库连接参数。 运行Spring-Boot项目。 ...
springboot 集成 quartz 集群 加 sql 等
03-13
springboot 集成 quartz 集群 加 sql 等 文章介绍 单机加集群都有 https://blog.csdn.net/weixin_42749765/article/details/88532413
浅谈SpringBoot集成Quartz动态定时任务
08-26
浅谈SpringBoot集成Quartz动态定时任务 SpringBoot是一个基于Java的开源框架，Quartz是一个功能强大的调度框架，两者的集成可以实现动态定时任务的执行。在本文中，我们将详细介绍SpringBoot集成Quartz动态定时...
spring boot集成quartz
m0_72167535的博客
11-17 2286
创建配置文件实现ApplicationRunner接口，实现run方法，在方法中，首先通过反射方式获取到要执行定时任务的类来创建jobdetail，然后根据执行规则创建执行的触发器trigger，再将jobdetail和trigger放到scheduler容器中，按照规则进行任务的执行。定时任务的全路径名称，执行的触发器以及任务名称，可以存放在数据库中，并在前端追加可视化画面来进行修改，删除及立即执行的功能。Quartz 中需要执行的任务详情，包括了任务的唯一标识和具体要执行的任务，可以通过。
Spring Boot 集成Quartz的简单入门
qq_41978323的博客
12-21 4626
Spring Boot集成Quartz的简单入门
springboot整合quartz(集群环境)
热门推荐
Button的博客
09-24 3万+
quartz
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值