相关概念

Quartz是一个任务调度框架
Job 表示一个工作，要执行的具体内容
JobDetail 表示一个具体的可执行的调度程序，Job 是这个可执行程调度程序所要执行的内容，另外 JobDetail 还包含了这个任务调度的方案和策略
Trigger 代表一个调度参数的配置，什么时候去调。
Scheduler 代表一个调度容器，一个调度容器中可以注册多个 JobDetail 和 Trigger。当 Trigger 与 JobDetail 组合，就可以被 Scheduler 容器调度了。
JobBuilder 定义和创建JobDetail实例的接口;
TriggerBuilder 定义和创建Trigger实例的接口；

使用示例

Demo

1.导依赖

  1. <dependency>
  2.   <groupId>org.springframework.boot</groupId>
  3.   <artifactId>spring-boot-starter-quartz</artifactId>
  4. </dependency>

2.配置以及配置类
application.yml

  1. tuya:
  2.   quartz:
  3.     config: config/quartz-dev.properties

quartz-dev.properties

  1. org.quartz.scheduler.instanceName = GlobalScheduler
  2. org.quartz.threadPool.threadCount = 10
  3. org.quartz.jobStore.class = org.quartz.impl.jdbcjobstore.JobStoreTX
  4. org.quartz.jobStore.driverDelegateClass = org.quartz.impl.jdbcjobstore.StdJDBCDelegate
  5. org.quartz.jobStore.tablePrefix = QRTZ_
  6. org.quartz.jobStore.dataSource = globalJobDataSource
  8. org.quartz.dataSource.globalJobDataSource.driver = com.mysql.cj.jdbc.Driver
  9. org.quartz.dataSource.globalJobDataSource.URL = jdbc:mysql://xxx:xxx/xxx?useUnicode=true&characterEncoding=utf-8&zeroDateTimeBehavior=convertToNull&transformedBitIsBoolean=true&autoReconnect=true&failOverReadOnly=false
  10. org.quartz.dataSource.globalJobDataSource.user = xxx
  11. org.quartz.dataSource.globalJobDataSource.password = xxx
  12. org.quartz.dataSource.globalJobDataSource.maxConnections = 5

AutowireBeanJobFactory(一般放启动类同级)

  1. **
  2.  * QuartzConfiguration
  3.  *
  4.  * @author Shenzhen Greatonce Co Ltd
  5.  * @author ginta
  6.  * @version 2019/4/29
  7.  */
  8. @Configuration
  9. public class QuartzConfiguration {
  11.   @Bean
  12.   public AutowireBeanJobFactory autowireBeanJobFactory() {
  13.     return new AutowireBeanJobFactory();
  14.   }
  16.   /**
  17.    * attention:
  18.    * Details：定义quartz调度工厂
  19.    */
  20.   @Bean(name = "globalScheduler")
  21.   public SchedulerFactoryBean schedulerFactory() {
  22.     SchedulerFactoryBean bean = new SchedulerFactoryBean();
  23.     // Quartz中的job自动注入spring容器托管的对象
  24.     bean.setJobFactory(autowireBeanJobFactory());
  25.     // 任意一个已定义的Job会覆盖现在的Job
  26.     bean.setOverwriteExistingJobs(true);
  27.     // 延时启动，应用启动1秒后,定时器才开始启动
  28.     bean.setStartupDelay(1);
  29.     return bean;
  30.   }
  31. }

DruidConnectionProvider

  1. package top.xinzhang0618.buge.core.quartz;
  3. import com.alibaba.druid.pool.DruidDataSource;
  4. import lombok.Getter;
  5. import lombok.Setter;
  6. import org.quartz.utils.ConnectionProvider;
  8. import java.sql.Connection;
  9. import java.sql.SQLException;
  11. /**
  12.  * @author xinzhang
  13.  * @date 2020/8/20 15:05
  14.  */
  15. @Getter
  16. @Setter
  17. public class DruidConnectionProvider implements ConnectionProvider {
  19.   private String driver;
  20.   private String url;
  21.   private String user;
  22.   private String password;
  23.   private String validationQuery;
  24.   private int maxConnection;
  25.   private int idleConnectionValidationSeconds;
  26.   private boolean validateOnCheckout;
  28.   private DruidDataSource datasource;
  30.   @Override
  31.   public Connection getConnection() throws SQLException {
  32.     return datasource.getConnection();
  33.   }
  35.   @Override
  36.   public void shutdown() throws SQLException {
  37.     if (this.datasource != null) {
  38.       datasource.close();
  39.     }
  40.   }
  42.   @Override
  43.   public void initialize() throws SQLException {
  44.     if (this.url == null) {
  45.       throw new SQLException("DBPool could not be created: DB URL cannot be null");
  46.     }
  48.     if (this.driver == null) {
  49.       throw new SQLException("DBPool driver could not be created: DB driver class name cannot be null!");
  50.     }
  52.     if (this.maxConnection < 0) {
  53.       throw new SQLException("DBPool maxConnectins could not be created: Max connections must be greater than zero!");
  54.     }
  56.     datasource = new DruidDataSource();
  57.     datasource.setDriverClassName(this.driver);
  58.     datasource.setUrl(this.url);
  59.     datasource.setUsername(this.user);
  60.     datasource.setPassword(this.password);
  61.     datasource.setMaxActive(this.maxConnection);
  63.     if (this.validationQuery != null) {
  64.       datasource.setValidationQuery(this.validationQuery);
  65.       if (!this.validateOnCheckout) {
  66.         datasource.setTestOnReturn(true);
  67.       } else {
  68.         datasource.setTestOnBorrow(true);
  69.       }
  70.       datasource.setValidationQueryTimeout(this.idleConnectionValidationSeconds);
  71.     }
  72.   }
  74. }

测试demo

  1. @Autowired
  2. private Scheduler globalScheduler;
  4. @PostMapping("/addJob/{productPublishId}")
  5. public void addJob(@PathVariable("productPublishId") Long productPublishId) throws SchedulerException {
  6.   PublishProduct publishProduct = productPublishService.getByKey(productPublishId);
  7.   JobKey jobKey = JobKey.jobKey("PUBLISH_PRODUCT_" + publishProduct.getPublishProductId());
  8.   JobDetail jobDetail = JobBuilder.newJob(PublishJob.class)
  9.       .withIdentity(jobKey).build();
  10.   jobDetail.getJobDataMap().put("PUBLISH_ID", productPublishId);
  11.   jobDetail.getJobDataMap().put("PUBLISH_TITLE", publishProduct.getPublishTitle());
  12.   TriggerKey triggerKey = TriggerKey.triggerKey("PUBLISH_PRODUCT_" + publishProduct.getPublishProductId());
  13.   CronTrigger trigger = TriggerBuilder.newTrigger().withIdentity(triggerKey).withSchedule(CronScheduleBuilder
  14.       .cronSchedule("0 58 14 29 4 ? 2019"))
  15.       .startNow()
  16.       .build();
  17.   globalScheduler.scheduleJob(jobDetail, trigger);
  19. }
  21. public static class PublishJob implements Job {
  23.   @Override
  24.   public void execute(JobExecutionContext context) throws JobExecutionException {
  25.     long publishId = context.getJobDetail().getJobDataMap().getLong("PUBLISH_ID");
  26.     String publishTitle = context.getJobDetail().getJobDataMap().getString("PUBLISH_TITLE");
  27.     System.out.println("PublishJob------------>" + publishTitle + "  " + publishId);
  28.   }
  29. }

定时投放任务

  1. /**
  2.  * 定时投放
  3.  */
  4. private void timedPublish(PublishProduct publishProduct) {
  5.   JobKey jobKey = JobKey.jobKey("PUBLISH_PRODUCT_" + publishProduct.getPublishProductId());
  6.   JobDetail jobDetail = JobBuilder.newJob(PublishJob.class)
  7.       .withIdentity(jobKey).build();
  8.   jobDetail.getJobDataMap().put("PUBLISH_PRODUCT_ID", publishProduct.getPublishProductId());
  9.   jobDetail.getJobDataMap().put("PUBLISH_TITLE", publishProduct.getPublishTitle());
  10.   jobDetail.getJobDataMap().put("TENANT_ID", BizContext.getTenantId());
  11.   jobDetail.getJobDataMap().put("OSS_SETTING", BizContext.getOssSetting());
  12.   TriggerKey triggerKey = TriggerKey.triggerKey("PUBLISH_PRODUCT_" + publishProduct.getPublishProductId());
  13.   LocalDateTime planTime = publishProduct.getPlanTime();
  14.   DateTimeFormatter formatter = DateTimeFormatter.ofPattern("ss mm HH dd MM ? yyyy");
  15.   String formatTimeStr = planTime.format(formatter);
  16.   CronTrigger trigger = TriggerBuilder.newTrigger().withIdentity(triggerKey).withSchedule(CronScheduleBuilder
  17.       .cronSchedule(formatTimeStr))
  18.       .startNow()
  19.       .build();
  20.   try {
  21.     globalScheduler.scheduleJob(jobDetail, trigger);
  22.     publishProduct.setPublishStatus(PublishStatus.ON_PUBLISH);
  23.     update(publishProduct);
  24.     LOGGER.log(publishProduct.getPublishProductId(), ActionConstants.MODIFY);
  25.   } catch (SchedulerException e) {
  26.     publishLOGGER.error("定时投放失败", e);
  27.     throw new BizException("定时投放失败", e);
  28.   }
  29. }
  1. /**
  2.  * 定时投放任务
  3.  */
  4. public class PublishJob implements Job {
  6.   private static final Logger LOGGER = TuyaLoggerFactory.getLogger(PublishJob.class);
  8.   @Autowired
  9.   private PublishProductService publishProductService;
  11.   @Override
  12.   public void execute(JobExecutionContext context) throws JobExecutionException {
  13.     long publishProductId = context.getJobDetail().getJobDataMap().getLong("PUBLISH_PRODUCT_ID");
  14.     String publishTitle = context.getJobDetail().getJobDataMap().getString("PUBLISH_TITLE");
  15.     BizContext.setTenantId(context.getJobDetail().getJobDataMap().getLong("TENANT_ID"));
  16.     BizContext.setOssSetting((TenantOssSetting) context.getJobDetail().getJobDataMap().get("OSS_SETTING"));
  17.     PublishProduct publishProduct = publishProductService.getByKey(publishProductId);
  18.     publishProductService.goPublish(publishProduct);
  19.     LOGGER.info("定时投放, publishProductId：{},publishTitle：{}", publishProductId, publishTitle);
  20.   }
  21. }

定时计费

JobConfiguration

  1. package com.greatonce.tuya.biz.impl.job;
  3. import com.greatonce.core.supports.quartz.QuartzTool;
  4. import com.greatonce.tuya.util.logging.TuyaLoggerFactory;
  5. import javax.annotation.PostConstruct;
  6. import org.quartz.CronTrigger;
  7. import org.quartz.JobDetail;
  8. import org.quartz.JobKey;
  9. import org.quartz.Scheduler;
  10. import org.quartz.SchedulerException;
  11. import org.slf4j.Logger;
  12. import org.springframework.beans.factory.annotation.Autowired;
  13. import org.springframework.beans.factory.annotation.Value;
  14. import org.springframework.context.annotation.Configuration;
  16. /**
  17.  * @author Shenzhen Greatonce Co Ltd
  18.  * @author xinzhang
  19.  * @version 2019/7/15
  20.  */
  21. @Configuration
  22. public class JobConfiguration {
  24.   private static final Logger LOGGER = TuyaLoggerFactory.getLogger(JobConfiguration.class);
  25.   private static final String PRODUCT_IMAGE_DAILY_ACCOUNT = "PRODUCT_IMAGE_DAILY_ACCOUNT";
  26.   @Autowired
  27.   private Scheduler globalScheduler;
  28.   @Value("${tuya.quarz.productImageDailyAccountJobCorn:0 30 23 * * ?}")
  29.   private String productImageDailyAccountJobCorn;
  32.   @PostConstruct
  33.   public void init() {
  34.     executeProductImageDailyAccountJob();
  35.   }
  38.   private void executeProductImageDailyAccountJob() {
  39.     try {
  40.       JobKey jobKey = JobKey.jobKey(PRODUCT_IMAGE_DAILY_ACCOUNT);
  41.       if (globalScheduler.checkExists(jobKey)) {
  42.         globalScheduler.deleteJob(jobKey);
  43.       }
  44.       JobDetail jobDetail = QuartzTool
  45.         .buildJobDetail(PRODUCT_IMAGE_DAILY_ACCOUNT, ProductImageDailyAccountJob.class);
  46.       CronTrigger trigger = QuartzTool
  47.         .buildCronTrigger(PRODUCT_IMAGE_DAILY_ACCOUNT, productImageDailyAccountJobCorn);
  48.       globalScheduler.scheduleJob(jobDetail, trigger);
  49.     } catch (SchedulerException e) {
  50.       LOGGER.error("定时计费异常, 异常信息: {}", e.getMessage());
  51.     }
  52.   }
  53. }

ProductImageDailyAccountJob

  1. package com.greatonce.tuya.biz.impl.job;
  3. import com.greatonce.core.util.Assert;
  4. import com.greatonce.core.util.JsonUtil;
  5. import com.greatonce.core.util.StringUtil;
  6. import com.greatonce.tuya.biz.ProductBalanceService;
  7. import com.greatonce.tuya.biz.ProductBillService;
  8. import com.greatonce.tuya.biz.StoreService;
  9. import com.greatonce.tuya.biz.TenantService;
  10. import com.greatonce.tuya.biz.TenantSettingService;
  11. import com.greatonce.tuya.schema.domain.ProductBalance;
  12. import com.greatonce.tuya.schema.domain.ProductBill;
  13. import com.greatonce.tuya.schema.domain.Tenant;
  14. import com.greatonce.tuya.schema.domain.TenantSetting;
  15. import com.greatonce.tuya.schema.enums.ProductType;
  16. import com.greatonce.tuya.schema.enums.TenantSettingType;
  17. import com.greatonce.tuya.schema.query.ProductBalanceQuery;
  18. import com.greatonce.tuya.schema.query.TenantQuery;
  19. import com.greatonce.tuya.util.BizContext;
  20. import com.greatonce.tuya.util.logging.TuyaLoggerFactory;
  21. import com.greatonce.tuya.util.velocity.VelocityUtil;
  22. import java.time.LocalDate;
  23. import java.util.HashMap;
  24. import java.util.List;
  25. import java.util.Map;
  26. import java.util.Set;
  27. import java.util.stream.Collectors;
  28. import javax.mail.MessagingException;
  29. import javax.mail.internet.MimeMessage;
  30. import org.quartz.Job;
  31. import org.quartz.JobExecutionContext;
  32. import org.quartz.JobExecutionException;
  33. import org.slf4j.Logger;
  34. import org.springframework.beans.factory.annotation.Autowired;
  35. import org.springframework.beans.factory.annotation.Value;
  36. import org.springframework.data.redis.core.RedisTemplate;
  37. import org.springframework.mail.javamail.JavaMailSender;
  38. import org.springframework.mail.javamail.MimeMessageHelper;
  40. /**
  41.  * 商品主图日结任务
  42.  *
  43.  * @author Shenzhen Greatonce Co Ltd
  44.  * @author xinzhang
  45.  * @version 2019/7/15
  46.  */
  47. public class ProductImageDailyAccountJob implements Job {
  49.   private static final Logger LOGGER = TuyaLoggerFactory.getLogger(ProductImageDailyAccountJob.class);
  50.   private static final String GENERATE_SUCCESS_TIMES = "GENERATE_SUCCESS_TIMES";
  51.   private static final String SYSTEM = "SYSTEM";
  52.   private static final String PRODUCT_BALANCE_NOTIFY_MAIL_TEMPLATE = "productBalanceNotifyMail.vm";
  53.   @Autowired
  54.   private RedisTemplate<String, Object> redisTemplate;
  55.   @Autowired
  56.   private TenantService tenantService;
  57.   @Autowired
  58.   private TenantSettingService tenantSettingService;
  59.   @Autowired
  60.   private StoreService storeService;
  61.   @Autowired
  62.   private ProductBillService productBillService;
  63.   @Autowired
  64.   private ProductBalanceService productBalanceService;
  65.   @Autowired
  66.   private JavaMailSender javaMailSender;
  67.   @Value("${spring.mail.username}")
  68.   private String sender;
  70.   @Override
  71.   public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
  72.     List<Tenant> tenantList = tenantService.list(new TenantQuery());
  73.     for (Tenant tenant : tenantList) {
  74.       BizContext.setTenantId(tenant.getTenantId());
  75.       int totalTimes = 0;
  76.       Map<Long, Integer> entries = redisTemplate.<Long, Integer>opsForHash()
  77.         .entries(tenant.getTenantId() + ":" + ProductType.PRODUCT_IMAGE + ":" + GENERATE_SUCCESS_TIMES);
  78.       if (!Assert.isEmpty(entries)) {
  79.         for (Long storeId : entries.keySet()) {
  80.           String storeName = storeService.getByKey(storeId).getStoreName();
  81.           ProductBill productBill = new ProductBill();
  82.           productBill.setTenantId(tenant.getTenantId());
  83.           productBill.setCreator(SYSTEM);
  84.           productBill.setConsumer(storeName);
  85.           productBill.setTimes(entries.get(storeId));
  86.           totalTimes += entries.get(storeId);
  87.           productBill.setProductType(ProductType.PRODUCT_IMAGE);
  88.           productBill.setAccountPeriod(LocalDate.now());
  89.           productBillService.create(productBill);
  90.           redisTemplate.<Long, Integer>opsForHash()
  91.             .delete(tenant.getTenantId() + ":" + ProductType.PRODUCT_IMAGE + ":" + GENERATE_SUCCESS_TIMES, storeId);
  92.         }
  93.         productBalanceService
  94.           .reduceProductBalanceRemainTimesAndFreezeTimes(tenant.getTenantId(), ProductType.PRODUCT_IMAGE, totalTimes);
  95.       }
  96.     }
  97.     List<ProductBalance> productBalanceList = productBalanceService.list(new ProductBalanceQuery());
  98.     Set<Long> tenantIds = productBalanceList.stream()
  99.       .filter(productBalance -> {
  100.         TenantSetting eg = new TenantSetting();
  101.         eg.setTenantId(productBalance.getTenantId());
  102.         eg.setTenantSettingType(TenantSettingType.APPLICATION);
  103.         String tenantSettingContent = tenantSettingService.getByExample(eg).getTenantSettingContent();
  104.         Integer warningValue = JsonUtil.toJSONObject(tenantSettingContent).getInteger("warningValue");
  105.         return productBalance.getRemainTimes() <= warningValue;
  106.       })
  107.       .map(ProductBalance::getTenantId).collect(Collectors.toSet());
  108.     sendRemainTimesNotifyEmail(tenantIds);
  109.   }
  111.   /**
  112.    * 发送剩余次数提醒邮件
  113.    *
  114.    * @param tenantIds 租户id列表
  115.    */
  116.   private void sendRemainTimesNotifyEmail(Set<Long> tenantIds) {
  117.     try {
  118.       for (Long tenantId : tenantIds) {
  119.         TenantSetting eg = new TenantSetting();
  120.         eg.setTenantSettingType(TenantSettingType.APPLICATION);
  121.         eg.setTenantId(tenantId);
  122.         TenantSetting tenantSetting = tenantSettingService.getByExample(eg);
  123.         String email = JsonUtil.toJSONObject(tenantSetting.getTenantSettingContent()).getString("email");
  124.         List<String> receivers = StringUtil.words(email);
  125.         String[] toAddress = receivers.toArray(new String[receivers.size()]);
  126.         String subject = "图鸦提醒邮件，产品余额不足，请及时充值！";
  127.         String tenantName = tenantService.getByKey(tenantId).getTenantName();
  129.         HashMap<String, Object> params = new HashMap<>(2);
  130.         params.put("tenantName", tenantName);
  131.         ProductBalanceQuery query = new ProductBalanceQuery();
  132.         query.setTenantId(tenantId);
  133.         List<ProductBalance> productBalanceList = productBalanceService.list(query);
  134.         params.put("productBalanceList", productBalanceList);
  135.         String text = VelocityUtil.generateStringByTemplate(PRODUCT_BALANCE_NOTIFY_MAIL_TEMPLATE, params);
  137.         MimeMessage message = javaMailSender.createMimeMessage();
  138.         MimeMessageHelper helper = new MimeMessageHelper(message, true, "UTF-8");
  139.         helper.setFrom(sender);
  140.         helper.setTo(toAddress);
  141.         helper.setSubject(subject);
  142.         helper.setText(text, true);
  143.         javaMailSender.send(message);
  144.       }
  145.     } catch (MessagingException e) {
  146.       LOGGER.error("发送图片生成剩余次数提醒邮件失败, 堆栈信息: {}", e);
  147.     }
  148.   }
  149. }

QuarzTool

核心corn包的工具类参考
QuartzTool

  2. public abstract class QuartzTool {
  3.   public QuartzTool() {
  4.   }
  6.   public static Scheduler scheduler(String name, JobFactory jobFactory) throws Exception {
  7.     SchedulerFactoryBean schedulerFactoryBean = new SchedulerFactoryBean();
  8.     schedulerFactoryBean.setSchedulerName(name);
  9.     schedulerFactoryBean.setJobFactory(jobFactory);
  10.     schedulerFactoryBean.setAutoStartup(true);
  11.     schedulerFactoryBean.afterPropertiesSet();
  12.     schedulerFactoryBean.start();
  13.     return schedulerFactoryBean.getObject();
  14.   }
  16.   public static JobDetail jobDetail(String name, Class<? extends Job> clazz) {
  17.     JobDetailFactoryBean jobDetailFactoryBean = new JobDetailFactoryBean();
  18.     jobDetailFactoryBean.setName(name);
  19.     jobDetailFactoryBean.setJobClass(clazz);
  20.     jobDetailFactoryBean.afterPropertiesSet();
  21.     return jobDetailFactoryBean.getObject();
  22.   }
  24.   public static SimpleTrigger simpleTrigger(String name, int interval, JobDetail jobDetail) {
  25.     SimpleTriggerFactoryBean simpleTriggerFactoryBean = new SimpleTriggerFactoryBean();
  26.     simpleTriggerFactoryBean.setName(name);
  27.     simpleTriggerFactoryBean.setJobDetail(jobDetail);
  28.     simpleTriggerFactoryBean.setRepeatInterval((long)(interval * 1000));
  29.     simpleTriggerFactoryBean.afterPropertiesSet();
  30.     return simpleTriggerFactoryBean.getObject();
  31.   }
  33.   public static CronTrigger cronTrigger(String name, String cron, JobDetail jobDetail) throws ParseException {
  34.     CronTriggerFactoryBean cronTriggerFactoryBean = new CronTriggerFactoryBean();
  35.     cronTriggerFactoryBean.setName(name);
  36.     cronTriggerFactoryBean.setJobDetail(jobDetail);
  37.     cronTriggerFactoryBean.setCronExpression(cron);
  38.     cronTriggerFactoryBean.afterPropertiesSet();
  39.     return cronTriggerFactoryBean.getObject();
  40.   }
  42.   public static String buildCron(LocalDateTime time) {
  43.     DateTimeFormatter formatter = DateTimeFormatter.ofPattern("ss mm HH dd MM ? yyyy");
  44.     return time.format(formatter);
  45.   }
  47.   public static JobDetail buildJobDetail(String jobKey, Class<? extends Job> clazz) {
  48.     return buildJobDetail(jobKey, clazz, (Map)null);
  49.   }
  51.   public static JobDetail buildJobDetail(String jobKey, Class<? extends Job> clazz, Map<String, Object> jobData) {
  52.     JobBuilder jobBuilder = JobBuilder.newJob(clazz).withIdentity(jobKey);
  53.     if (jobData != null) {
  54.       jobBuilder.usingJobData(new JobDataMap(jobData));
  55.     }
  57.     return jobBuilder.build();
  58.   }
  60.   public static CronTrigger buildCronTrigger(String triggerKey, String cron) {
  61.     return (CronTrigger)TriggerBuilder.newTrigger().withIdentity(triggerKey).withSchedule(CronScheduleBuilder.cronSchedule(cron)).startNow().build();
  62.   }
  64.   public static SimpleTrigger buildSimpleTrigger(String triggerKey, int seconds) {
  65.     return (SimpleTrigger)TriggerBuilder.newTrigger().withIdentity(triggerKey).withSchedule(SimpleScheduleBuilder.simpleSchedule().withIntervalInSeconds(seconds).repeatForever()).startNow().build();
  66.   }
  68.   public static <T> T getJobData(JobExecutionContext jobExecutionContext, String key) {
  69.     return jobExecutionContext.getJobDetail().getJobDataMap() != null && jobExecutionContext.getJobDetail().getJobDataMap().containsKey(key) ? jobExecutionContext.getJobDetail().getJobDataMap().get(key) : null;
  70.   }
  71. }

AutowireBeanJobFactory

  1. public class AutowireBeanJobFactory extends SpringBeanJobFactory implements ApplicationContextAware {
  2.   private transient AutowireCapableBeanFactory beanFactory;
  4.   public AutowireBeanJobFactory() {
  5.   }
  7.   public void setApplicationContext(ApplicationContext context) {
  8.     this.beanFactory = context.getAutowireCapableBeanFactory();
  9.   }
  11.   protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception {
  12.     Object job = super.createJobInstance(bundle);
  13.     this.beanFactory.autowireBean(job);
  14.     return job;
  15.   }
  16. }

工具类使用参考

  1. String name = giftStrategy.getGiftStrategyId() + EXECUTE + execute.getGiftStrategyExecuteId();
  2.     JobDetail jobDetail = QuartzTool
  3.         .jobDetail(name, StaticStrategyExecuteJob.class);
  4.     jobDetail.getJobDataMap().put(GIFT_STRATEGY_ID, giftStrategy.getGiftStrategyId());
  5.     jobDetail.getJobDataMap().put(GIFT_STRATEGY_EXECUTE_ID, execute.getGiftStrategyExecuteId());
  6.     SimpleTrigger simpleTrigger = QuartzTool.simpleTrigger(name, 0, jobDetail);
  7.     try {
  8.       globalScheduler.scheduleJob(jobDetail, simpleTrigger);
  9.     } catch (SchedulerException e) {
  10.       throw new OmsException("静态策略执行定时任务添加失败, giftStrategyId: {0}, GiftStrategyExecuteId: {1}",
  11.           giftStrategy.getGiftStrategyId(), execute.getGiftStrategyExecuteId());
  12.     }

quarz错过触发时机的处理

参考: https://yq.aliyun.com/articles/114262

触发器超时的情况

1.系统重启错过定时任务
2.Trigger被暂停时, 有任务被错过
3.线程池中的所有线程被占用, 导致misfire
4.有状态任务在下次触发时间到达时, 上次执行还没结束

  1. #判定job为misfire的阈值，这里设置为4S
  2. org.quartz.jobStore.misfireThreshold = 4000

调度器怎么处理超时

  1. timeout < misfireThreshold
    超时的触发器（超时时间小于misfireThreshold）在获取到运行线程后，将会立即运行前面错过的作业job，然后按照前面制定的周期性任务正常运行。
    2. timeout >= misfireThreshold
    调度器引擎为简单触发器SimpleTrigger和表达式CronTrigger提供了多种处理策略，我们可以在定义触发器时指定需要的策略。
    2.1 对于SimpleTrigger的处理策略
  • MISFIRE_INSTRUCTION_FIRE_NOW ： 调度引擎在MisFire的情况下，将任务(JOB)马上执行一次。需要注意的是 这个指令通常被用做只执行一次的Triggers，也就是没有重复的情况（non-repeating），如果这个Triggers的被安排的执行次数大于0。那么这个执行与 MISFIRE_INSTRUCTION_RESCHEDULE_NOW_WITH_REMAINING_REPEAT_COUNT 相同。
  • MISFIRE_INSTRUCTION_RESCHEDULE_NOW_WITH_EXISTING_REPEAT_COUNT： 调度引擎重新调度该任务，repeat count 保持不变，按照原有制定的执行方案执行repeat count次，但是，如果当前时间，已经晚于 end-time，那么这个触发器将不会再被触发。举个例子：比如一个触发器设置的时间是 10:00 执行时间间隔10秒 重复10次。那么当10：07秒的时候调度引擎可以执行这个触发器的任务，然后按照原有制定的时间间隔执行10次。但是如果触发器设置的执行时间是10：00，结束时间为10：10，由于种种原因导致该触发器在10：11分才能被调度引擎触发，这时，触发器将不会被触发了。
  • MISFIRE_INSTRUCTION_RESCHEDULE_NEXT_WITH_REMAINING_COUNT： 这个策略跟上面的 MISFIRE_INSTRUCTION_RESCHEDULE_NOW_WITH_EXISTING_REPEAT_COUNT 策略类似，唯一的区别就是调度器触发触发器的时间不是“现在” 而是下一个 scheduled time。
  • MISFIRE_INSTRUCTION_RESCHEDULE_NOW_WITH_REMAINING_REPEAT_COUNT： 这个策略跟上面的策略 MISFIRE_INSTRUCTION_RESCHEDULE_NOW_WITH_EXISTING_REPEAT_COUNT 比较类似，调度引擎重新调度该任务，repeat count 是剩余应该执行的次数，也就是说本来这个任务应该执行10次，但是已经错过了3次，那么这个任务就还会执行7次。
  • MISFIRE_INSTRUCTION_RESCHEDULE_NEXT_WITH_REMAINING_COUNT： 这个策略跟上面的 MISFIRE_INSTRUCTION_RESCHEDULE_NEXT_WITH_REMAINING_COUNT 策略类似，区别就是repeat count 是剩余应该执行的次数而不是全部的执行次数。比如一个任务应该在2:00执行，repeat count=5，时间间隔5秒， 但是在2:07才获得执行的机会，那任务不会立即执行，而是按照机会在2点10秒执行。
  • MISFIRE_INSTRUCTION_IGNORE_MISFIRE_POLICY： 这个策略跟上面的 MISFIRE_INSTRUCTION_RESCHEDULE_NOW_WITH_EXISTING_REPEAT_COUNT 策略类似，但这个策略是忽略所有的超时状态，快速执行之前错过的次数，然后再按照之前制定的周期触发触发器。举个例子，一个SimpleTrigger 每个15秒钟触发, 但是超时了5分钟才获得执行的机会，那么这个触发器会被快速连续调用20次， 追上前面落下的执行次数。

2.2 对于CronTrigger的处理策略

  • MISFIRE_INSTRUCTION_FIRE_ONCE_NOW： 指示触发器超时后会被立即安排执行。
  • MISFIRE_INSTRUCTION_DO_NOTHING： 这个策略与策略 MISFIRE_INSTRUCTION_FIRE_ONCE_NOW 正好相反，它不会被立即触发，而是获取下一个被触发的时间，并且如果下一个被触发的时间超出了end-time 那么触发器就不会被执行。

定时任务调度

image.png

注意理解:
间隔秒数==>下多长时间
延迟分钟==>下什么时候的, 当前时间-延迟时间
任务间隔==>多久下一次

  1. package com.greatonce.oms.job.executor;
  3. import com.greatonce.oms.biz.base.StoreDownloadConfigService;
  4. import com.greatonce.oms.biz.base.StoreService;
  5. import com.greatonce.oms.domain.base.Store;
  6. import com.greatonce.oms.domain.base.StoreDownloadConfig;
  7. import com.greatonce.oms.job.executor.download.StoreDownloadJob;
  8. import java.time.LocalDateTime;
  9. import org.quartz.Job;
  10. import org.quartz.JobExecutionContext;
  11. import org.slf4j.Logger;
  12. import org.slf4j.LoggerFactory;
  13. import org.springframework.beans.factory.annotation.Autowired;
  15. /**
  16.  * 下载抽象类.
  17.  *
  18.  * @author ginta
  19.  * @author Shenzhen Greatonce Co Ltd
  20.  * @version 2018-07-22
  21.  */
  22. public abstract class AbstractDownloader implements Job {
  24.   private final Logger LOGGER = LoggerFactory.getLogger(AbstractDownloader.class);
  25.   @Autowired
  26.   private StoreService storeService;
  27.   @Autowired
  28.   private StoreDownloadConfigService storeDownloadConfigService;
  30.   /**
  31.    * 日志
  32.    */
  33.   protected abstract Logger getLogger();
  35.   /**
  36.    * 执行下载
  37.    *
  38.    * 如果未到延迟时间不下载
  39.    * 如果开始时间+间隔秒数>当前时间则结束时间为当前时间，否则为开始时间+间隔秒数
  40.    *
  41.    * @param config 下载配置
  42.    * @param store 店铺
  43.    * @param endTime 计算好的结束时间
  44.    */
  45.   protected abstract void doDownload(StoreDownloadConfig config, Store store, LocalDateTime endTime);
  47.   public void download(StoreDownloadConfig config) {
  48.     Store store = storeService.getByKey(config.getStoreId());
  49.     if (store == null || !store.isEnable()) {
  50.       getLogger().debug("店铺不存在或已禁用：{}", config.getStoreName());
  51.       return;
  52.     }
  53.     LocalDateTime now = LocalDateTime.now();
  54.     LocalDateTime endTime = config.getBeginTime().plusSeconds(config.getIntervalSeconds());
  55.     endTime = endTime.isAfter(now) ? now : endTime;
  57.     LocalDateTime deadline = now.minusMinutes(config.getDelayMinutes());
  58.     if (endTime.isAfter(deadline)) {
  59.       if (getLogger().isDebugEnabled()) {
  60.         getLogger()
  61.             .debug("未到延迟时间：{},{},{}", config.getStoreName(), config.getDownloadType().caption(),
  62.                 config.getBeginTime());
  63.       }
  64.       return;
  65.     }
  67.     doDownload(config, store, endTime);
  68.     config.setBeginTime(endTime);
  69.     storeDownloadConfigService.modify(config);
  70.   }
  73.   @Override
  74.   public void execute(JobExecutionContext jobExecutionContext) {
  75.     Long configId = jobExecutionContext.getJobDetail().getJobDataMap().getLong(StoreDownloadJob.DOWNLOAD_CONFIG_KEY);
  76.     StoreDownloadConfig config = storeDownloadConfigService.getByKey(configId);
  77.     try {
  78.       download(config);
  79.     } catch (Exception e) {
  80.       LOGGER.info(config.getStoreName() + "：" + config.getDownloadType().caption() + "下载异常,堆栈信息:", e);
  81.     }
  82.   }
  83. }

举例:
问: 有品发票的下载配置初始化的时候给多少合适==>这种不需要太及时的就可以跑的频次低一点, 可以5分钟跑一次，拉10分钟的数据
答: 可以设置延迟分钟10, 间隔秒数1060和任务间隔560