java项目配置定时器

依赖导入：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-quartz</artifactId>
</dependency>

代码实现：

1、
import org.quartz.spi.TriggerFiredBundle;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
import org.springframework.scheduling.quartz.AdaptableJobFactory;
import org.springframework.stereotype.Component;

@Component
public class JobFactory extends AdaptableJobFactory {

    private AutowireCapableBeanFactory factory;

    @Autowired
    public void setFactory(AutowireCapableBeanFactory factory) {
        this.factory = factory;
    }

    @Override
    protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception {
        Object job = super.createJobInstance(bundle);
        factory.autowireBean(job);
        return job;
    }
}

2、
import lombok.extern.log4j.Log4j2;
import org.quartz.SchedulerException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationListener;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.event.ContextRefreshedEvent;


@Configuration
@Log4j2
public class QuartzJobListener implements ApplicationListener<ContextRefreshedEvent> {

    private QuartzConfig quartzConfig;

    @Autowired
    public void setQuartzConfig(QuartzConfig quartzConfig) {
        this.quartzConfig = quartzConfig;
    }

    @Override
    public void onApplicationEvent(ContextRefreshedEvent event) {
        try {
            this.quartzConfig.start();
            log.info("Quartz定时任务任务启动");
        } catch (SchedulerException e) {
            log.error("Quartz定时任务启动失败:  ", e);
        }
    }

}

3、
import com.alonginfo.nmka.timedtask.task.DeleteUselessDataTimedtask;
import com.alonginfo.nmka.timedtask.task.EarlyManagementTimedtask;
import com.alonginfo.nmka.timedtask.task.SurveyInhabitantIsHereTimedtask;
import lombok.extern.log4j.Log4j2;
import org.quartz.*;
import org.quartz.spi.JobFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;

@Configuration
@Log4j2
public class QuartzConfig {

    private JobFactory jobFactory;

    @Autowired
    public void setJobFactory(JobFactory jobFactory) {
        this.jobFactory = jobFactory;
    }

    @Bean
    public SchedulerFactoryBean schedulerFactoryBean() {
        SchedulerFactoryBean factory = new SchedulerFactoryBean();
        factory.setJobFactory(jobFactory);
        return factory;
    }

    @Bean(name = "scheduler")
    public Scheduler scheduler() {
        return schedulerFactoryBean().getScheduler();
    }

    public void start() throws SchedulerException {
        //执行自动预警判定任务定时开启
        earlyManagementTimedtask();
        surveyInhabitantIsHereTimedtask();
        //执行增量无用数据清理定时开启
        deleteUselessData();
    }

    /**
     * 执行自动预警判定任务定时开启
     * @throws SchedulerException
     */
    private void earlyManagementTimedtask() throws SchedulerException{
        JobDetail jobDetail = JobBuilder
                .newJob(EarlyManagementTimedtask.class)
                .withIdentity("earlyManagementTimedtask", "every-day")
                .storeDurably()
                .build();
        //每日凌晨4点执行一次
        CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule("0 0 3 * * ?");
//        CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule("0/30 * * * * ?");//测试使用，每30s执行一次
        CronTrigger cronTrigger = TriggerBuilder
                .newTrigger()
                .withIdentity("earlyManagementTimedtask", "every-day")
                .withSchedule(scheduleBuilder)
                .build();
        scheduler().scheduleJob(jobDetail, cronTrigger);
    }

    private void surveyInhabitantIsHereTimedtask() throws SchedulerException{
        JobDetail jobDetail = JobBuilder
                .newJob( SurveyInhabitantIsHereTimedtask.class)
                .withIdentity("surveyInhabitantIsHereTimedtask", "every-day")
                .storeDurably()
                .build();
        //每日凌晨5点执行一次
        CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule("0 0 5 * * ?");
//        CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule("0/30 * * * * ?");//测试使用，每30s执行一次
        CronTrigger cronTrigger = TriggerBuilder
                .newTrigger()
                .withIdentity("surveyInhabitantIsHereTimedtask", "every-day")
                .withSchedule(scheduleBuilder)
                .build();
        scheduler().scheduleJob(jobDetail, cronTrigger);
    }

    /**
     * 执行增量无用数据清理定时开启
     * @throws SchedulerException
     */
    private void deleteUselessData() throws SchedulerException{
        JobDetail jobDetail = JobBuilder
                .newJob(DeleteUselessDataTimedtask.class)
                .withIdentity("deleteUselessDataTimedtask", "every-day")
                .storeDurably()
                .build();
        //每日凌晨3:30执行一次
        CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule("0 30 3 * * ?");
        CronTrigger cronTrigger = TriggerBuilder
                .newTrigger()
                .withIdentity("deleteUselessDataTimedtask", "every-day")
                .withSchedule(scheduleBuilder)
                .build();
        scheduler().scheduleJob(jobDetail, cronTrigger);
    }
}

4、
import com.alonginfo.nmka.constant.ParamEnum;
import com.alonginfo.nmka.entity.Param;
import com.alonginfo.nmka.mapper.*;
import com.alonginfo.nmka.service.ParamService;
import lombok.extern.log4j.Log4j2;
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.beans.factory.annotation.Autowired;

@Log4j2
public class DeleteUselessDataTimedtask implements Job {

    @Autowired
    private ReportMapper reportMapper;

    @Autowired
    private ReportAuditMapper reportAuditMapper;

    @Autowired
    private NucleicResultMapper nucleicResultMapper;

    @Autowired
    private SiteRecordMapper siteRecordMapper;

    @Autowired
    private PassRecordMapper passRecordMapper;

    @Autowired
    private TripMapper tripMapper;

    @Autowired
    private ParamService paramService;

    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        log.info("执行增量无用数据清理定时开启：");
        String timeScope = "60";//默认60天
        //查询清理范围
//        Param param = paramService.findParamByName(ParamEnum.DELETE_TIME_SCOPE.getPvalue());
//        if(null != param){
//            timeScope = param.getPvalue();
//        }
        //删除报备表数据
        int reportNum = reportMapper.deleteReportInfo(timeScope);
        //删除报备审核表数据
        int reportAuditNum = reportAuditMapper.deleteReportAuditInfo(timeScope);
        //删除核酸检测表数据
        int nucleicNum = nucleicResultMapper.deleteNucleicResultInfo(timeScope);
        //删除场所记录表数据
        int siteRecordNum = siteRecordMapper.deleteSiteRecordInfo(timeScope);
        //删除通行记录表数据
        int passRecordNum = passRecordMapper.deletePassRecordInfo(timeScope);
        //删除行程卡表数据
        int tripNum = tripMapper.deleteTripInfo(timeScope);
        log.info("执行增量无用数据清理结束：报备表删除数据：{}，报备审核删除数据：{}，" +
                "核酸检测表删除数据：{}，场所记录表删除数据：{}，通行记录表删除数据：{}，" +
                "行程卡表删除数据：{}",reportNum,reportAuditNum,nucleicNum,siteRecordNum,passRecordNum,tripNum);
    }