springboot redis 分布式锁 quartz定时任务

1、现在服务器基本上是集群、负债均衡、微服务。如果用到quartz定时任务，定时任务会在各个服务器上重复执行，轻则浪费服务器资源，重则造成数据紊乱。 quartz定时任务提供了集群方式，但还需为其创建数据库表。比较麻烦和复杂。所有本人用到redis分布式锁来处理该问题。

edis分布式锁是通过setnx命令实现的。该命令的作用是，当往redis中存入一个值时，会先判断该值对应的key是否存在，如果存在则返回0，如果不存在，则将该值存入redis并返回1。根据这个特性，我们在程序中，每次都调用setIfAbsent(该方法是setnx命令的实现)方法，来模拟是否获取到锁，如果返回true，则说明该key值不存在，表示获取到锁；如果返回false，则说明该key值存在，已经有程序在使用这个key值了，从而实现了类似加锁的功能。

代码实现：

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;
    }
}
 

package com.byd.masoct.quartz;

import 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;
/**
 * 任务调度处理
 * 
 */

@Configuration
@EnableScheduling
public class QuartzScheduler {
    @Autowired
    private MyJobFactory myJobFactory;
    
    @Bean 
    public SchedulerFactoryBean schedulerFactoryBean(Trigger updateTrigger) throws IOException {
        SchedulerFactoryBean factory = new SchedulerFactoryBean();
        factory.setOverwriteExistingJobs(true); 
        // 延时启动 
        factory.setStartupDelay(20); 
        // 自定义Job Factory，用于Spring注入
        factory.setJobFactory(myJobFactory);
        factory.setTriggers(updateTrigger); return factory; 
     }
     
    @Bean(name = "updateJobDetail") 
    public JobDetailFactoryBean uploadJobDetail() {
        JobDetailFactoryBean jobDetail = new JobDetailFactoryBean(); 
        jobDetail.setJobClass(SchedulerQuartzJob.class); 
        return jobDetail; 
    }
     
    @Bean(name = "updateTrigger") 
    public CronTriggerFactoryBean updateTriggerFactoryBean(JobDetail updateJobDetail) { 
        CronTriggerFactoryBean trigger = new CronTriggerFactoryBean();
        //trigger.setCronExpression("0/5 * * * * ?"); // 每五秒执行一次
        trigger.setCronExpression("0 0 5 * * ?"); //每天凌晨5点钟触发一次
        trigger.setJobDetail(updateJobDetail);
        return trigger; 
        }
}
 

import java.util.Date;
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.data.redis.core.RedisTemplate;
import org.springframework.transaction.annotation.Transactional;

import com.byd.masoct.common.utils.DateUtils;
import com.byd.masoct.pojo.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;
    @Autowired
    private BoradcastServive boradcastServive;
    
    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("任务开始：" + System.currentTimeMillis());
         boolean lock = false;
        try {
            //使用redis分布式锁解决quartz定时任务部署重复执行问题
            lock = redisTemplate.opsForValue().setIfAbsent(KEY, LOCK);
            logger.info("是否获取到锁:" + lock);
            if(lock){
                //业务处理
                Date date = new Date();
                String pushDate = DateUtils.dateToStr(date);
                List<MasoctBroadcast> list;
                try {
                    list = boradcastServive.findBroadcastByPushDate(pushDate);
                    if(list != null && list.size() > 0){
                        for (MasoctBroadcast masoctBroadcast : list) {
                            masoctBroadcast.setContentStatus("4");//表示已过期
                            //更新数据库
                            boradcastServive.updateMasoctBroadcastByPushDate(masoctBroadcast);
                        }
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }else {
                logger.info("没有获取到锁，不执行任务!");
               
            }
        } finally{
            if (lock) {
                redisTemplate.delete(KEY);
                logger.info("任务结束，释放锁!");
            } else {
                logger.info("没有获取到锁，无需释放锁!");
            }

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

}