quartz多个定时任务实现方式

1、pom.xml

<!-- quartz 定时任务 -->
        <dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
        </dependency>
        <!-- quartz 定时任务 -->

2、生成job的工厂交给spring管理

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;

@Configuration
public class MyJobFactory extends AdaptableJobFactory {
    
    @Autowired
    private AutowireCapableBeanFactory capableBeanFactory;
    
    @Override
    protected Object createJobInstance(TriggerFiredBundle bundle)throws Exception {
        //调用父类的方法
        Object jreateJobInstance = super.createJobInstance(bundle);
        //进行注入
        capableBeanFactory.autowireBean(jreateJobInstance);    
        return jreateJobInstance;
    }
}

3、任务调度器 Scheduler

mport java.io.IOException;
import org.quartz.JobDetail;
import org.quartz.Trigger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.quartz.CronTriggerFactoryBean;
import org.springframework.scheduling.quartz.JobDetailFactoryBean;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;
/**
 * 任务调度处理 两个任务调度 firstTrigger 和 secondTrigger
 * 
 */

@Configuration
@EnableScheduling
public class QuartzScheduler {
    @Autowired
    private MyJobFactory myJobFactory;
    
    @Bean 
    public SchedulerFactoryBean schedulerFactoryBean(Trigger firstTrigger,Trigger secondTrigger) throws IOException {
        SchedulerFactoryBean factory = new SchedulerFactoryBean();
        factory.setOverwriteExistingJobs(true); 
        // 延时启动 
        factory.setStartupDelay(20); 
        // 自定义Job Factory，用于Spring注入
        factory.setJobFactory(myJobFactory);
        factory.setTriggers(firstTrigger,secondTrigger); //设置多个定时任务配置
        return factory; 
     }
     
    @Bean(name = "firstJobDetail") 
    public JobDetailFactoryBean firstJobDetail() {
        JobDetailFactoryBean jobDetail = new JobDetailFactoryBean(); 
        jobDetail.setJobClass(SchedulerQuartzJob.class); 
        return jobDetail; 
    }
     
    @Bean(name = "firstTrigger") 
    public CronTriggerFactoryBean firstTriggerFactoryBean(JobDetail firstJobDetail) { 
        CronTriggerFactoryBean trigger = new CronTriggerFactoryBean();
        //trigger.setCronExpression("0/5 * * * * ?"); // 每五秒执行一次
        trigger.setCronExpression("0 0 5 * * ?"); //每天凌晨5点钟触发一次
        trigger.setJobDetail(firstJobDetail);
        return trigger; 
    }
    
    @Bean(name = "secondJobDetail") 
    public JobDetailFactoryBean uploadJobDetail() {
        JobDetailFactoryBean jobDetail = new JobDetailFactoryBean(); 
        jobDetail.setJobClass(StatisticsBrodcastJob.class); 
        return jobDetail; 
    }
     
    @Bean(name = "secondTrigger") 
    public CronTriggerFactoryBean secondTriggerFactoryBean(JobDetail secondJobDetail) { 
        CronTriggerFactoryBean trigger = new CronTriggerFactoryBean();
        //trigger.setCronExpression("0/10 * * * * ?"); // 每6秒执行一次
        trigger.setCronExpression("0 58 23 * * ?"); //每天23点58分触发一次
        trigger.setJobDetail(secondJobDetail);
        return trigger; 
    }
    
}

4、任务类：能够注入业务类，两任务  SchedulerQuartzJob 和

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.transaction.annotation.Transactional;
import com.byd.masoct.common.utils.DateUtils;
import com.byd.masoct.pojo.auto.MasoctBroadcast;
import com.byd.masoct.service.BoradcastServive;

/**
 * 实现定时任务job接口
 *
 */
@Transactional //添加事务
public class SchedulerQuartzJob implements Job {
    protected static Logger logger=LoggerFactory.getLogger(SchedulerQuartzJob.class);
    @Autowired
    private RedisTemplate<String, String>  redisTemplate;

   //注入业务service层
    @Autowired
    private 业务service  业务service;
    
    private static final String LOCK = "boradcast-job-lock";

    private static final String KEY = "boradcastlock";
    @Override
    public void execute(JobExecutionContext arg0)throws JobExecutionException {
        System.out.println("SchedulerQuartzJob任务开始：" + System.currentTimeMillis());
         boolean lock = false;
        try {
            //使用redis分布式锁解决quartz定时任务部署重复执行问题
            lock = redisTemplate.opsForValue().setIfAbsent(KEY, LOCK);
            logger.info("SchedulerQuartzJob是否获取到锁:" + lock);
            if(lock){
                try { 
                  //业务处理   //业务处理   //业务处理

                } catch (Exception e) {
                    e.printStackTrace();
                }
            }else {
                logger.info("SchedulerQuartzJob没有获取到锁，不执行任务!");
               
            }
        } finally{
            if (lock) {
                redisTemplate.delete(KEY);
                logger.info("SchedulerQuartzJob任务结束，释放锁!");
            } else {
                logger.info("SchedulerQuartzJob没有获取到锁，无需释放锁!");
            }

        }
        System.out.println("SchedulerQuartzJob任务结束：" + System.currentTimeMillis());
        
    }

}
 

任务二; 

 

import java.util.List;

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.transaction.annotation.Transactional;

import com.byd.masoct.common.enums.ResultEnum;
import com.byd.masoct.common.utils.JsonUtils;
import com.byd.masoct.common.utils.RedisUtil;
import com.byd.masoct.pojo.auto.MasoctBroadcast;
import com.byd.masoct.service.BoradcastServive;

/**
 *
 * @version 创建时间：2019年4月15日 下午4:59:56
 * 类说明
 */
@Transactional //添加事务
public class StatisticsBrodcastJob implements Job{
    protected static Logger logger=LoggerFactory.getLogger(StatisticsBrodcastJob.class);
    @Autowired
    private RedisTemplate<String, String>  redisTemplate;
   //注入业务service层
    @Autowired
    private 业务service  业务service;

    
    @Value("${MASOCTBROADCAST_NUMBER_LIST}")
    private String MASOCTBROADCAST_NUMBER_LIST;
    
    private static final String LOCK = "statisticsBrodcast-job-lock";

    private static final String KEY = "statisticsBrodcastlock";
    @Override
    public void execute(JobExecutionContext arg0) throws JobExecutionException {
        System.out.println("StatisticsBrodcastJob任务1执行....");
        
        boolean lock = false;
        try {
            //使用redis分布式锁解决quartz定时任务部署重复执行问题
            lock = redisTemplate.opsForValue().setIfAbsent(KEY, LOCK);
            logger.info("StatisticsBrodcastJob是否获取到锁:" + lock);
            if(lock){
                
                try {
                  //业务处理
                    
                } catch (Exception e) {
                    //添加自定义异常信息
                    e.printStackTrace();
                }
            }else {
                logger.info("没有获取到锁，不执行任务!");
              
            }
        } finally{
            if (lock) {
               redisTemplate.delete(KEY);
               logger.info("任务结束，释放锁!");
           } else {
               logger.info("没有获取到锁，无需释放锁!");
           }

        }
        System.out.println("StatisticsBrodcastJob任务结束：" + System.currentTimeMillis());
        
    }

}