spring mvc 定时任务corn每小时 springmvc动态定时任务

springmvc使用定时任务quartz

项目需求

1.定时执行任务
2.可动态新增，修改，删除定时任务

jar包

<!-- 定时器quartz使用jar包-->
<dependency>
    <groupId>org.quartz-scheduler</groupId>
    <artifactId>quartz</artifactId>
    <version>2.2.1</version>
</dependency>

java实现类

1.job 工厂实例方法重写QuartzJobFactory

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 QuartzJobFactory extends AdaptableJobFactory {

    @Autowired
    private AutowireCapableBeanFactory autowireCapableBeanFactory;

    /**
     * 重写job实例化方法
     * 将实例化对象手动添加到spring IOC容器并完成对象注入
     *
     * @param bundle
     * @return
     * @throws Exception
     */
    @Override
    protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception {
        //父类方法调用
        Object jobInstance = super.createJobInstance(bundle);
        //spring注入
        autowireCapableBeanFactory.autowireBean(jobInstance);
        return jobInstance;
    }
}

2.定时器中心处理器QuartzManager

import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.Date;

@Service
public class QuartzManager {

    private static SchedulerFactory schedulerFactory = new StdSchedulerFactory();

    @Autowired
    private QuartzJobFactory quartzJobFactory;

    /**
     * 新增一个定时任务
     *
     * @param jobName          任务名
     * @param jobGroupName     任务组名
     * @param triggerName      触发器名
     * @param triggerGroupName 触发器组名
     * @param jobClass         任务类
     * @param cron             时间设置
     * @param jobDataMap       任务参数
     */
    @SuppressWarnings("unchecked")
    public void addJob(String jobName, String jobGroupName, String triggerName, String triggerGroupName, Class jobClass, String cron, JobDataMap jobDataMap) {
        //调度类获取
        Scheduler scheduler = null;
        try {
            scheduler = schedulerFactory.getScheduler();
            //设置job实例工厂【实现手动spring注入】
            scheduler.setJobFactory(quartzJobFactory);

            //job实例与设置其所属身份
            JobDetail jobDetail = JobBuilder.newJob(jobClass).usingJobData(jobDataMap).withIdentity(jobName, jobGroupName).build();
            //触发器
            TriggerBuilder<Trigger> triggerBuilder = TriggerBuilder.newTrigger();
            //触发器身份所属设置
            triggerBuilder.withIdentity(triggerName, triggerGroupName);
            triggerBuilder.startNow();
            // 触发器时间设定
            triggerBuilder.withSchedule(CronScheduleBuilder.cronSchedule(cron));
            // 创建Trigger对象
            CronTrigger trigger = (CronTrigger) triggerBuilder.build();

            // 调度容器设置JobDetail和Trigger
            scheduler.scheduleJob(jobDetail, trigger);
            //启动
            if (!scheduler.isShutdown()) {
                scheduler.start();
            }
            System.out.println("新增定时任务=【" + jobName + "=" + jobGroupName + "】" + cron);
        } catch (SchedulerException e) {
            e.printStackTrace();
            System.out.println("新增定时任务【" + jobName + jobGroupName + "】失败");
        }
    }


    /**
     * 修改定时任务触发时间
     *
     * @param jobName          任务名
     * @param jobGroupName     任务组名
     * @param triggerName      触发器名
     * @param triggerGroupName 触发器组名
     * @param cron             时间
     */
    public void modifyJobTime(String jobName, String jobGroupName, String triggerName, String triggerGroupName, String cron) {
        Scheduler scheduler = null;
        try {
            scheduler = schedulerFactory.getScheduler();
            //获取触发器所属key
            TriggerKey triggerKey = TriggerKey.triggerKey(triggerName, triggerGroupName);
            CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);
            //如果触发器不存在，不往下执行
            if (trigger == null) {
                return;
            }
            //获取当前执行时间
            String cronExpression = trigger.getCronExpression();
            //新触发器时间与旧触发器时间不一致时修改触发器时间
            if (!cronExpression.equals(cron)) {
                /** 方式一 ：调用 rescheduleJob 开始 */
                // 触发器
                TriggerBuilder<Trigger> triggerBuilder = TriggerBuilder.newTrigger();
                // 触发器名,触发器组
                triggerBuilder.withIdentity(triggerName, triggerGroupName);
                triggerBuilder.startNow();
                // 触发器时间设定
                triggerBuilder.withSchedule(CronScheduleBuilder.cronSchedule(cron));
                // 创建Trigger对象
                trigger = (CronTrigger) triggerBuilder.build();
                // 方式一 ：修改一个任务的触发时间（覆盖旧数据）
                scheduler.rescheduleJob(triggerKey, trigger);
                /** 方式一 ：调用 rescheduleJob 结束 */

                /** 方式二：先删除，然后在创建一个新的Job  */
                //JobDetail jobDetail = sched.getJobDetail(JobKey.jobKey(jobName, jobGroupName));
                //Class<? extends Job> jobClass = jobDetail.getJobClass();
                //removeJob(jobName, jobGroupName, triggerName, triggerGroupName);
                //addJob(jobName, jobGroupName, triggerName, triggerGroupName, jobClass, cron);
                /** 方式二 ：先删除，然后在创建一个新的Job */
                System.out.println("更新定时任务=【" + jobName + "=" + jobGroupName + "】" + cron);
            }
        } catch (SchedulerException e) {
            e.printStackTrace();
            System.out.println("更新定时任务【" + jobName + jobGroupName + "】失败");
        }

    }

    /**
     * 移除一个定时任务
     *
     * @param jobName          任务名
     * @param jobGroupName     任务组名
     * @param triggerName      触发器名
     * @param triggerGroupName 触发器组名
     */
    public void removeJob(String jobName, String jobGroupName, String triggerName, String triggerGroupName) {
        Scheduler scheduler = null;
        try {
            scheduler = schedulerFactory.getScheduler();
            TriggerKey triggerKey = TriggerKey.triggerKey(triggerName, triggerGroupName);
            scheduler.pauseTrigger(triggerKey);// 停止触发器
            scheduler.unscheduleJob(triggerKey);// 移除触发器
            scheduler.deleteJob(JobKey.jobKey(jobName, jobGroupName));// 删除任务
            System.out.println("移除定时任务=【" + jobName + "=" + jobGroupName + "】");
        } catch (SchedulerException e) {
            e.printStackTrace();
            System.out.println("移除定时任务【" + jobName + jobGroupName + "】失败");
        }
    }

    /**
     * 启动所有定时任务
     */
    public void startJobs() {
        try {
            Scheduler scheduler = schedulerFactory.getScheduler();
            scheduler.start();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 关闭所有定时任务
     */
    public void shutdownJobs() {
        try {
            Scheduler scheduler = schedulerFactory.getScheduler();
            if (!scheduler.isShutdown()) {
                scheduler.shutdown();
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

3自定义定时任务类（具体执行内容）

import org.quartz.Job;
import org.quartz.JobDataMap;
import org.quartz.JobExecutionContext;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.Date;
import java.util.List;

@Component
public class ReminderJob implements Job {

    @Autowired
    private EduScheduleService eduScheduleService;

    /**
     * 任务执行内容
     *
     * @param jobExecutionContext
     */
    @Override
    public void execute(JobExecutionContext jobExecutionContext) {
        //参数获取
        JobDataMap jobDataMap = jobExecutionContext.getJobDetail().getJobDataMap();
        //逻辑代码编写
    }
}

4.使用样例

import org.quartz.JobDataMap;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationListener;
import org.springframework.context.event.ContextRefreshedEvent;
import org.springframework.stereotype.Service;

import java.util.HashMap;
import java.util.List;

/**
 * @author ljc
 * @Title:
 * @Package
 * @Description: 启动监听类【项目启动完成或刷新完成时触发】
 * @date 2021/3/116:16
 */
@Service
public class StartupListener implements ApplicationListener<ContextRefreshedEvent> {
    @Autowired
    private QuartzManager quartzManager;

    @Override
    public void onApplicationEvent(ContextRefreshedEvent event) {
    	String cron = "0 0 12 * * ?";
    	JobDataMap dataMap = new JobDataMap();
        dataMap.put("testName", "a");
		quartzManager.addJob("a", "a1", "b", "b1", ReminderJob.class, cron, dataMap);
    }
}

cron表达式详解link

5.项目停止时会发现报错

Web应用程序[edu_api]似乎启动了一个名为[DefaultQuartzScheduler_Worker-1]的线程，但未能停止它。这很可能会造成内存泄漏
这是因为项目停止时，而quartz未停止，可以监听事件来停止quartz的全部定时任务

import org.apache.commons.lang3.StringUtils;
import org.quartz.JobDataMap;
import org.springframework.stereotype.Component;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.support.WebApplicationContextUtils;

import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import java.util.HashMap;
import java.util.List;

public class MyContextListener implements ServletContextListener {
    private QuartzManager quartzManager;
    private WebApplicationContext webApplicationContext;

    public void setQuartzManager(QuartzManager quartzManager) {
        this.quartzManager = quartzManager;
    }

    /**
     * 项目初始化
     *
     * @param sce
     */
    @Override
    public void contextInitialized(ServletContextEvent sce) {
      
    }

    /**
     * 项目销毁
     *
     * @param sce
     */
    @Override
    public void contextDestroyed(ServletContextEvent sce) {
        System.out.println("销毁=======》>");
        if (webApplicationContext == null)
            webApplicationContext = WebApplicationContextUtils.getWebApplicationContext(sce.getServletContext());
        quartzManager = (QuartzManager) webApplicationContext.getBean("quartzManager");
        quartzManager.shutdownJobs();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

web.xml 文件添加监听

<listener>
	<!-- 注意修改类路径 -->
	<listener-class>*.*.*MyContextListener</listener-class>
</listener>