java 定时任务quartz的使用

 

1.maven

<dependency>
    <groupId>org.quartz-scheduler</groupId>
    <artifactId>quartz</artifactId>
    <version>2.3.2</version>
</dependency>
<dependency>
    <groupId>org.quartz-scheduler</groupId>
    <artifactId>quartz-jobs</artifactId>
    <version>2.3.2</version>
</dependency>

2.config

job：

package org.springblade.config;

import org.quartz.spi.TriggerFiredBundle;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.quartz.AdaptableJobFactory;

/**
 * <p>
 * 自定义 JobFactory
 * </p>
 *
 */
@Configuration
public class CustomJobFactory extends AdaptableJobFactory {
   @Autowired
   private AutowireCapableBeanFactory autowireCapableBeanFactory;

   /**
    * Create the job instance, populating it with property values taken
    * from the scheduler context, job data map and trigger data map.
    *
    * @param bundle
    */
   @Override
   protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception {
      Object jobInstance = super.createJobInstance(bundle);
      autowireCapableBeanFactory.autowireBean(jobInstance);
      return jobInstance;
   }
}

QuartzConfig：

package org.springblade.config;

import lombok.SneakyThrows;
import org.quartz.Scheduler;
import org.quartz.SchedulerFactory;
import org.quartz.impl.StdSchedulerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * <p>
 * 配置类
 * </p>
 *
 */
@Configuration
public class QuartzConfig {
   @Autowired
   private CustomJobFactory customJobFactory;

   @SneakyThrows
   @Bean
   public Scheduler scheduler() {
      SchedulerFactory schedulerFactory = new StdSchedulerFactory();
      Scheduler scheduler = schedulerFactory.getScheduler();
      // 自定义 JobFactory 使得在 Quartz Job 中可以使用 @Autowired
      scheduler.setJobFactory(customJobFactory);
      scheduler.start();
      return scheduler;
   }

}


启动类：

package org.springblade.scheduler;

import org.quartz.*;
import org.quartz.impl.StdScheduler;
import org.springblade.job.FunActivityDownJob;
import org.springblade.job.FunActivityShelfJob;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

import java.time.LocalDateTime;

/**
 * <p>
 * 启动类
 * </p>
 *
 */
@Configuration
@ComponentScan(basePackages = "org.springblade")
public class SchedulerApplication {

   //秒       分    时  每月第几天(?)   月       每周第几天(?)  （年）
   private static final String CRON_EXPRESSION_3SECONDS = "0 0 0 * * ? ";//每天凌晨0:00:00执行一次,?用于无指定日期

   public static void main(String[] args) throws SchedulerException {
      ApplicationContext applicationContext = new AnnotationConfigApplicationContext(SchedulerApplication.class);
      ((AnnotationConfigApplicationContext) applicationContext).start();
      Scheduler scheduler = (StdScheduler) applicationContext.getBean("scheduler");
      initQuartzJobs(scheduler);
   }

   public static void initQuartzJobs(Scheduler scheduler) throws SchedulerException {
      // shelfActivity上架活动
      System.out.println("job shelfActivity上架活动 start: " + LocalDateTime.now() + "");
      JobDetail job1 = JobBuilder.newJob(FunActivityShelfJob.class).withIdentity(FunActivityShelfJob.class.getName()).build();
      //SimpleScheduleBuilder demo1Scheduler = SimpleScheduleBuilder.simpleSchedule().repeatForever().withIntervalInSeconds(9999992);
      Trigger  trigger1 = TriggerBuilder.newTrigger().withIdentity(FunActivityShelfJob.class.getName()).withSchedule(CronScheduleBuilder.cronSchedule(CRON_EXPRESSION_3SECONDS)).build();
      scheduler.scheduleJob(job1, trigger1);

      // downActivity下架活动
      System.out.println("job downActivity下架活动 start: " + LocalDateTime.now() + "");
      JobDetail job2 = JobBuilder.newJob(FunActivityDownJob.class).withIdentity(FunActivityDownJob.class.getName()).build();
      Trigger  trigger2 = TriggerBuilder.newTrigger().withIdentity(FunActivityDownJob.class.getName()).withSchedule(CronScheduleBuilder.cronSchedule(CRON_EXPRESSION_3SECONDS)).build();
      scheduler.scheduleJob(job2, trigger2);

      // JobDemo2
//    JobDetail job2 = JobBuilder.newJob(JobDemo2.class).withIdentity(JobDemo2.class.getName()).build();
//    SimpleScheduleBuilder demo2Scheduler = SimpleScheduleBuilder.simpleSchedule().repeatForever().withIntervalInSeconds(5);
//    SimpleTrigger trigger2 = TriggerBuilder.newTrigger().withIdentity(JobDemo2.class.getName()).withSchedule(demo2Scheduler).build();
//
//    scheduler.scheduleJob(job2, trigger2);
   }
}

获取bean工具类springutil；

package org.springblade.util;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.ApplicationEvent;
import org.springframework.stereotype.Component;

/**
 * <p>
 * Spring 工具类
 * </p>
 *
 */
@Slf4j
@Component
public class SpringUtil implements ApplicationContextAware {
   private static ApplicationContext context;

   @Override
   public void setApplicationContext(ApplicationContext context) throws BeansException {
      SpringUtil.context = context;
   }

   /**
    * 获取 Spring Bean
    *
    * @param clazz 类
    * @param <T>   泛型
    * @return 对象
    */
   public static <T> T getBean(Class<T> clazz) {
      if (clazz == null) {
         return null;
      }
      return context.getBean(clazz);
   }

   /**
    * 获取 Spring Bean
    *
    * @param bean 名称
    * @param <T>  泛型
    * @return 对象
    */
   @SuppressWarnings("unchecked")
   public static <T> T getBean(String bean) {
      if (bean == null) {
         return null;
      }
      return (T) context.getBean(bean);
   }

   /**
    * 获取 Spring Bean
    *
    * @param beanName 名称
    * @param clazz    类
    * @param <T>      泛型
    * @return 对象
    */
   public static <T> T getBean(String beanName, Class<T> clazz) {
      if (null == beanName || "".equals(beanName.trim())) {
         return null;
      }
      if (clazz == null) {
         return null;
      }
      return (T) context.getBean(beanName, clazz);
   }

   /**
    * 获取上下文
    *
    * @return 上下文
    */
   public static ApplicationContext getContext() {
      if (context == null) {
         throw new RuntimeException("There has no Spring ApplicationContext!");
      }
      return context;
   }

   /**
    * 发布事件
    *
    * @param event 事件
    */
   public static void publishEvent(ApplicationEvent event) {
      if (context == null) {
         return;
      }
      try {
         context.publishEvent(event);
      } catch (Exception ex) {
         log.error(ex.getMessage());
      }
   }

}

3.demo job

package org.springblade.job;

import lombok.extern.slf4j.Slf4j;
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springblade.service.impl.DemoService;
import org.springframework.beans.factory.annotation.Autowired;

/**
 * <p>
 * 测试定时任务 1
 * </p>
 *
 */
@Slf4j
public class JobDemo1 implements Job {
   @Autowired
   private DemoService demoService;

    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
//    FunThemeRepository test = SpringUtil.getBean(FunThemeRepository.class);
//    Integer a =test.shelfTheme();
        demoService.echo("JobDemo1");
    }
}

4.调用接口

package org.springblade.service.impl;

import lombok.extern.slf4j.Slf4j;
import org.springblade.repository.FunThemeRepository;
import org.springblade.util.PropUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
import java.time.LocalDateTime;

/**
 * <p>
 * 测试 Spring Bean
 * </p>
 *
 */
@Slf4j
@Service
public class DemoService {

   @Autowired
   private FunThemeRepository funThemeRepository;

   public void echo(String module) {
        System.out.println("[DemoService] echo in [" + module + "] at " + LocalDateTime.now() + "");
      //Integer a= funThemeRepository.shelfTheme();
      String a="";
      try
      {
         String test = PropUtils.getProp("FunActivityTheme");
         a=loadJSONFforISP("http://localhost:9102/activityInfo/shelfActivity");
      }
      catch (Exception e)
      {

      }
      System.out.println("[DemoService] echo1 in [" + module + "] at " + LocalDateTime.now() + "");
    }

   public String loadJSONFforISP(String url) {
      StringBuilder json = new StringBuilder(); //返回json数据
      //String ISPTimeOut = DictionaryUtils.codeToName("ISP","ISPTimeOut");//设置响应时间
      try {
         URL u = new URL(url);//设置url
         HttpURLConnection yc = (HttpURLConnection) u.openConnection();//设置请求相关参数
         yc.setRequestMethod("POST");
         yc.setDoOutput(true);
         yc.setDoInput(true);
         yc.setAllowUserInteraction(false);
         yc.setUseCaches(false);
         //yc.setConnectTimeout(Integer.parseInt(ISPTimeOut));
         yc.setRequestProperty("Accept-Charset", "utf-8");
         yc.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
         yc.setRequestProperty("User-Agent", "Mozilla/4.0 (compatible; MSIE 5.0; Windows NT; DigExt)");
         yc.connect();
         BufferedInputStream bis = new BufferedInputStream(yc.getInputStream());
         BufferedReader in = new BufferedReader(new InputStreamReader(bis, "utf-8"));
         String inputLine = null;
         while ((inputLine = in.readLine()) != null) {
            json.append(inputLine);
         }
         in.close();
      } catch (Exception e) {
         e.printStackTrace();
      }
      return json.toString();
   }
}