Quartz与SpringMVC的整合

本是古典何须时尚 2022-05-24 20:14 217阅读 0赞

前言：

要将quartz的任务持久化，能动态添加任务、修改任务、暂停任务、动态修改触发时间.

调度器：Scheduler；工作:JobDetail ;触发器：Trigger

一、在pom文件中引入jar包

这里只定义quartz需要的jar包,其它和spring相关的省略

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

二、配置相应的xml文件

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
    	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    	xsi:schemaLocation="
            http://www.springframework.org/schema/beans 
            http://www.springframework.org/schema/beans/spring-beans-4.2.xsd">
    	<bean id="scheduler" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
            
            <property name="dataSource" ref="dataSource" />
            
            <property name="quartzProperties">
                <props>
                    
                    <prop key="org.quartz.scheduler.instanceName">fwoneScheduler</prop>
                    
                    <prop key="org.quartz.scheduler.instanceId">AUTO</prop>
                    
                    <prop key="org.quartz.threadPool.class">org.quartz.simpl.SimpleThreadPool</prop>
                    <prop key="org.quartz.threadPool.threadCount">20</prop>
                    <prop key="org.quartz.threadPool.threadPriority">5</prop>
                    
                    
                    <prop key="org.quartz.jobStore.class">org.quartz.impl.jdbcjobstore.JobStoreTX</prop>
                    
                    
                    <prop key="org.quartz.jobStore.isClustered">true</prop>
    
                    <prop key="org.quartz.jobStore.clusterCheckinInterval">150000</prop>
                    <prop key="org.quartz.jobStore.maxMisfiresToHandleAtATime">1</prop>
                    
                    <prop key="org.quartz.jobStore.misfireThreshold">12000</prop>
    				
                    <prop key="org.quartz.jobStore.tablePrefix">QRTZ_</prop>
                </props>
            </property>
    
            <property name="schedulerName" value="fwoneScheduler" />
    
            
            <property name="startupDelay" value="30" />
    
            <property name="applicationContextSchedulerContextKey" value="applicationContextKey" />
    
            
            <property name="overwriteExistingJobs" value="true" />
    
            
            <property name="autoStartup" value="true" />
            
            <property name="waitForJobsToCompleteOnShutdown" value="true"/>
    
        </bean>
           
    	   <bean id="job1" class="com.fwone.demo.Job1Demo"/>
    </beans>

三、建立相关的数据表

因为要持久化到数据库中，所以要建立相关的数据表

**1.1.qrtz\_blob\_triggers** : 以**Blob** 类型存储的**触发器**。

**1.2.qrtz\_calendars**：存放**日历信息**， quartz可配置一个日历来指定一个时间范围。

**1.3.qrtz\_cron\_triggers**：存放**cron类型**的触发器。

**1.4.qrtz\_fired\_triggers**：存放**已触发**的触发器。

**1.5.qrtz\_job\_details**：存放一个**jobDetail**信息。

**1.6.qrtz\_job\_listeners**：job\*\*监听器\*\*。

**1.7.qrtz\_locks**： 存储程序的**悲观锁的信息**(假如使用了悲观锁)。

**1.8.qrtz\_paused\_trigger\_graps**：存放**暂停掉**的触发器。

**1.9.qrtz\_scheduler\_state**：调度器状态。

**1.10.qrtz\_simple\_triggers**：**简单触发器**的信息。

**1.11.qrtz\_trigger\_listeners**：**触发器监听器**。 **1.12.qrtz\_triggers**：**触发器**的**基本信息**。

DROP TABLE IF EXISTS QRTZ_FIRED_TRIGGERS;
    DROP TABLE IF EXISTS QRTZ_PAUSED_TRIGGER_GRPS;
    DROP TABLE IF EXISTS QRTZ_SCHEDULER_STATE;
    DROP TABLE IF EXISTS QRTZ_LOCKS;
    DROP TABLE IF EXISTS QRTZ_SIMPLE_TRIGGERS;
    DROP TABLE IF EXISTS QRTZ_SIMPROP_TRIGGERS;
    DROP TABLE IF EXISTS QRTZ_CRON_TRIGGERS;
    DROP TABLE IF EXISTS QRTZ_BLOB_TRIGGERS;
    DROP TABLE IF EXISTS QRTZ_TRIGGERS;
    DROP TABLE IF EXISTS QRTZ_JOB_DETAILS;
    DROP TABLE IF EXISTS QRTZ_CALENDARS;
    
    
    CREATE TABLE QRTZ_JOB_DETAILS
      (
        SCHED_NAME VARCHAR(120) NOT NULL,
        JOB_NAME  VARCHAR(200) NOT NULL,
        JOB_GROUP VARCHAR(200) NOT NULL,
        DESCRIPTION VARCHAR(250) NULL,
        JOB_CLASS_NAME   VARCHAR(250) NOT NULL,
        IS_DURABLE VARCHAR(1) NOT NULL,
        IS_NONCONCURRENT VARCHAR(1) NOT NULL,
        IS_UPDATE_DATA VARCHAR(1) NOT NULL,
        REQUESTS_RECOVERY VARCHAR(1) NOT NULL,
        JOB_DATA BLOB NULL,
        PRIMARY KEY (SCHED_NAME,JOB_NAME,JOB_GROUP)
    );
    
    CREATE TABLE QRTZ_TRIGGERS
      (
        SCHED_NAME VARCHAR(120) NOT NULL,
        TRIGGER_NAME VARCHAR(200) NOT NULL,
        TRIGGER_GROUP VARCHAR(200) NOT NULL,
        JOB_NAME  VARCHAR(200) NOT NULL,
        JOB_GROUP VARCHAR(200) NOT NULL,
        DESCRIPTION VARCHAR(250) NULL,
        NEXT_FIRE_TIME BIGINT(13) NULL,
        PREV_FIRE_TIME BIGINT(13) NULL,
        PRIORITY INTEGER NULL,
        TRIGGER_STATE VARCHAR(16) NOT NULL,
        TRIGGER_TYPE VARCHAR(8) NOT NULL,
        START_TIME BIGINT(13) NOT NULL,
        END_TIME BIGINT(13) NULL,
        CALENDAR_NAME VARCHAR(200) NULL,
        MISFIRE_INSTR SMALLINT(2) NULL,
        JOB_DATA BLOB NULL,
        PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
        FOREIGN KEY (SCHED_NAME,JOB_NAME,JOB_GROUP)
            REFERENCES QRTZ_JOB_DETAILS(SCHED_NAME,JOB_NAME,JOB_GROUP)
    );
    
    CREATE TABLE QRTZ_SIMPLE_TRIGGERS
      (
        SCHED_NAME VARCHAR(120) NOT NULL,
        TRIGGER_NAME VARCHAR(200) NOT NULL,
        TRIGGER_GROUP VARCHAR(200) NOT NULL,
        REPEAT_COUNT BIGINT(7) NOT NULL,
        REPEAT_INTERVAL BIGINT(12) NOT NULL,
        TIMES_TRIGGERED BIGINT(10) NOT NULL,
        PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
        FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
            REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
    );
    
    CREATE TABLE QRTZ_CRON_TRIGGERS
      (
        SCHED_NAME VARCHAR(120) NOT NULL,
        TRIGGER_NAME VARCHAR(200) NOT NULL,
        TRIGGER_GROUP VARCHAR(200) NOT NULL,
        CRON_EXPRESSION VARCHAR(200) NOT NULL,
        TIME_ZONE_ID VARCHAR(80),
        PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
        FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
            REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
    );
    
    CREATE TABLE QRTZ_SIMPROP_TRIGGERS
      (          
        SCHED_NAME VARCHAR(120) NOT NULL,
        TRIGGER_NAME VARCHAR(200) NOT NULL,
        TRIGGER_GROUP VARCHAR(200) NOT NULL,
        STR_PROP_1 VARCHAR(512) NULL,
        STR_PROP_2 VARCHAR(512) NULL,
        STR_PROP_3 VARCHAR(512) NULL,
        INT_PROP_1 INT NULL,
        INT_PROP_2 INT NULL,
        LONG_PROP_1 BIGINT NULL,
        LONG_PROP_2 BIGINT NULL,
        DEC_PROP_1 NUMERIC(13,4) NULL,
        DEC_PROP_2 NUMERIC(13,4) NULL,
        BOOL_PROP_1 VARCHAR(1) NULL,
        BOOL_PROP_2 VARCHAR(1) NULL,
        PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
        FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP) 
        REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
    );
    
    CREATE TABLE QRTZ_BLOB_TRIGGERS
      (
        SCHED_NAME VARCHAR(120) NOT NULL,
        TRIGGER_NAME VARCHAR(200) NOT NULL,
        TRIGGER_GROUP VARCHAR(200) NOT NULL,
        BLOB_DATA BLOB NULL,
        PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
        FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
            REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
    );
    
    CREATE TABLE QRTZ_CALENDARS
      (
        SCHED_NAME VARCHAR(120) NOT NULL,
        CALENDAR_NAME  VARCHAR(200) NOT NULL,
        CALENDAR BLOB NOT NULL,
        PRIMARY KEY (SCHED_NAME,CALENDAR_NAME)
    );
    
    CREATE TABLE QRTZ_PAUSED_TRIGGER_GRPS
      (
        SCHED_NAME VARCHAR(120) NOT NULL,
        TRIGGER_GROUP  VARCHAR(200) NOT NULL, 
        PRIMARY KEY (SCHED_NAME,TRIGGER_GROUP)
    );
    
    CREATE TABLE QRTZ_FIRED_TRIGGERS
      (
        SCHED_NAME VARCHAR(120) NOT NULL,
        ENTRY_ID VARCHAR(95) NOT NULL,
        TRIGGER_NAME VARCHAR(200) NOT NULL,
        TRIGGER_GROUP VARCHAR(200) NOT NULL,
        INSTANCE_NAME VARCHAR(200) NOT NULL,
        FIRED_TIME BIGINT(13) NOT NULL,
        SCHED_TIME BIGINT(13) NOT NULL,
        PRIORITY INTEGER NOT NULL,
        STATE VARCHAR(16) NOT NULL,
        JOB_NAME VARCHAR(200) NULL,
        JOB_GROUP VARCHAR(200) NULL,
        IS_NONCONCURRENT VARCHAR(1) NULL,
        REQUESTS_RECOVERY VARCHAR(1) NULL,
        PRIMARY KEY (SCHED_NAME,ENTRY_ID)
    );
    
    CREATE TABLE QRTZ_SCHEDULER_STATE
      (
        SCHED_NAME VARCHAR(120) NOT NULL,
        INSTANCE_NAME VARCHAR(200) NOT NULL,
        LAST_CHECKIN_TIME BIGINT(13) NOT NULL,
        CHECKIN_INTERVAL BIGINT(13) NOT NULL,
        PRIMARY KEY (SCHED_NAME,INSTANCE_NAME)
    );
    
    CREATE TABLE QRTZ_LOCKS
      (
        SCHED_NAME VARCHAR(120) NOT NULL,
        LOCK_NAME  VARCHAR(40) NOT NULL, 
        PRIMARY KEY (SCHED_NAME,LOCK_NAME)
    );

四、具体实现

1、我本地自己建立的一个保存任务的数据表

DROP TABLE IF EXISTS `schedule_job`;
    CREATE TABLE `schedule_job` (
      `job_id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '任务id',
      `bean_name` varchar(200) DEFAULT NULL COMMENT 'spring bean名称',
      `method_name` varchar(100) DEFAULT NULL COMMENT '方法名',
      `params` varchar(2000) DEFAULT NULL COMMENT '参数',
      `cron_expression` varchar(100) DEFAULT NULL COMMENT 'cron表达式',
      `status` tinyint(4) DEFAULT NULL COMMENT '任务状态',
      `remark` varchar(255) DEFAULT NULL COMMENT '备注',
      `create_time` datetime DEFAULT NULL COMMENT '创建时间',
      PRIMARY KEY (`job_id`)
    ) ENGINE=InnoDB AUTO_INCREMENT=10 DEFAULT CHARSET=utf8 ROW_FORMAT=DYNAMIC COMMENT='定时任务';

2、项目启动时先初始化

说明：我的项目集成了mybatis,像数据库调用的那些就不说了。

ScheduleJobEntity这个是对应表\`schedule\_job\`建立的实体类，schedulerJobDao是数据调用接口。

/**
    	 * 项目启动时，初始化定时器
    	 */
    	@PostConstruct
    	public void myInit(){
    		//先查出数据库中有多少个任务,将其初始化
    		List<ScheduleJobEntity> list=schedulerJobDao.queryList(null);
    		if(list!=null)
    		{
    			list.forEach
    				(
    					scheduleJob->
    					{
    						//获取各个任务对应的触发器,如果不为空,则更新;为空则创建任务;
    						Trigger trigger= MyScheduleUtils.getTrigger(scheduler,scheduleJob.getJobId());
    						if(trigger==null)
                                 MyScheduleUtils.createScheduleJob(scheduler,scheduleJob);
    						else
    							 MyScheduleUtils.updateScheduleJob(scheduler,scheduleJob);
    					}
    			    );
    		}
    	}

3、建立工具类MyScheduleUtils

package com.fwone.utils;
    
    import com.fwone.entity.ScheduleJobEntity;
    import org.quartz.*;
    
    public class MyScheduleUtils {
        private static final String JOB_NAME="TASK_";
        /**
         * 获取触发器Key
         * @param jobId
         * @return
         */
        public static TriggerKey getTriggerKey(Long jobId){
            return TriggerKey.triggerKey(JOB_NAME+jobId);
        }
    
        public static JobKey getJobKey(Long jobId){
            return JobKey.jobKey(JOB_NAME+jobId);
        }
        /**
         * 获取触发器
         * @param scheduler
         * @param jobId
         * @return
         */
        public static CronTrigger getTrigger(Scheduler scheduler, Long jobId){
            try {
                JobDetail jobDetail=scheduler.getJobDetail(getJobKey(jobId));
                Class c=jobDetail.getJobClass();
                System.out.println(c);
                return (CronTrigger)scheduler.getTrigger(getTriggerKey(jobId));
            } catch (SchedulerException e) {
                throw new RRException("获取定时任务CronTrigger出现异常",e);
            }
        }
    
        /**
         * 创建任务
         * @param scheduler
         * @param scheduleJob
         */
        public static void createScheduleJob(Scheduler scheduler, ScheduleJobEntity scheduleJob){
            try {
                /** 重要:
                 *  定义一个job，并绑定到我们自定义的MyScheduleJob的class对象
                 *  这里并不会马上创建一个MyScheduleJob实例，实例创建是在scheduler安排任务触发执行时创建的
                 *  这种机制也为后面使用Spring集成提供了便利
                 */
                JobDetail jobDetail = JobBuilder.newJob(MyScheduleJob.class)
                        .withIdentity(getJobKey(scheduleJob.getJobId()))
                        .build();
                /** 重要:
                 *  定义一个表达式调度构建器:不触发立即执行,等待下次Cron触发频率到达时刻开始按照Cron频率依次执行
                 *  如果任务失败，策略为：所有的misfire不管，执行下一个周期的任务
                 */
                CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder
                        .cronSchedule(scheduleJob.getCronExpression())
                        .withMisfireHandlingInstructionDoNothing();
    
                /**重要:
                 * 按新的cronExpression表达式构建一个新的trigger
                 */
                Trigger trigger = TriggerBuilder
                        .newTrigger()
                        .withIdentity(getTriggerKey(scheduleJob.getJobId()))
                        .withSchedule(cronScheduleBuilder)
                        .build();
                //放入参数,运行时的方法可以获取
                jobDetail.getJobDataMap().put(ScheduleJobEntity.JOB_PARAM_KEY, scheduleJob);
    
                /**重要:
                 * 把定义好的job放入调度器scheduler
                 */
                scheduler.scheduleJob(jobDetail, trigger);
    
                //判断是否暂停任务
                if(scheduleJob.getStatus()==null||
                        scheduleJob.getStatus()== Constant.ScheduleStatus.PAUSE.getValue())
                    pauseJob(scheduler,scheduleJob.getJobId());
            }catch (SchedulerException e){
                throw new RRException("创建定时任务失败", e);
            }
    
        }
    
        /**
         * 更新任务
         * @param scheduler
         * @param scheduleJob
         */
        public static void updateScheduleJob(Scheduler scheduler, ScheduleJobEntity scheduleJob){
            try {
            CronScheduleBuilder scheduleBuilder=CronScheduleBuilder
                    .cronSchedule(scheduleJob.getCronExpression())
                    .withMisfireHandlingInstructionDoNothing();
    
            CronTrigger trigger=getTrigger(scheduler,scheduleJob.getJobId());
            //按新的cronExpression表达式重新构建trigger
            trigger=trigger.getTriggerBuilder()
                    .withIdentity(getTriggerKey(scheduleJob.getJobId()))
                    .withSchedule(scheduleBuilder)
                    .build();
            trigger.getJobDataMap().put(ScheduleJobEntity.JOB_PARAM_KEY,scheduleJob);
            scheduler.rescheduleJob(getTriggerKey(scheduleJob.getJobId()),trigger);
    
            //判断是否暂停任务
            if(scheduleJob.getStatus()==null||
                     scheduleJob.getStatus()== Constant.ScheduleStatus.PAUSE.getValue())
                 pauseJob(scheduler,scheduleJob.getJobId());
            } catch (SchedulerException e) {
               throw new RRException("更新定时任务失败",e);
            }
        }
    
        /**
         * 暂停任务
         * @param scheduler
         * @param jobId
         */
        public static void pauseJob(Scheduler scheduler,Long jobId){
            try {
                scheduler.pauseJob(getJobKey(jobId));
            } catch (SchedulerException e) {
                throw new RRException("暂停定时任务失败", e);
            }
        }
    
        /**
         * 立即运行一次任务
         * @param scheduler
         * @param scheduleJob
         */
        public static void run(Scheduler scheduler,ScheduleJobEntity scheduleJob){
            try {
                JobDataMap jobDataMap=new JobDataMap();
                jobDataMap.put(ScheduleJobEntity.JOB_PARAM_KEY,scheduleJob);
                scheduler.triggerJob(getJobKey(scheduleJob.getJobId()),jobDataMap);
            } catch (SchedulerException e) {
                throw new RRException("立即执行任务失败",e);
            }
        }
    
        /**
         *恢复任务
         * @param scheduler
         * @param jobId
         */
        public static void resumeJob(Scheduler scheduler,Long jobId){
            try {
                scheduler.resumeJob(getJobKey(jobId));
            } catch (SchedulerException e) {
               throw new RRException("恢复任务失败",e);
            }
        }
    }

自定义工作类，用于 执行任务

package com.fwone.utils;
    
    import com.fwone.entity.ScheduleJobEntity;
    import org.quartz.JobExecutionContext;
    import org.quartz.JobExecutionException;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
    import org.springframework.scheduling.quartz.QuartzJobBean;
    import java.util.concurrent.Future;
    
    /**
    **另外Trigger中也可以设置JobDataMap属性，这是为了在多个Trigger中使用相同的Job。
    **JobExecutionContext 将会合并JobDetail与Trigger的JobDataMap，如果其中属性名相同，后者将覆盖前者。
    **可以使用JobExecutionContext.getMergedJobDataMap()方法来获取合并后的JobDataMap。
     */
    public class MyScheduleJob extends QuartzJobBean {
        private Logger logger= LoggerFactory.getLogger(MyScheduleJob.class);
        @Override
        protected void executeInternal(JobExecutionContext context) throws JobExecutionException {
            ScheduleJobEntity scheduleJob=(ScheduleJobEntity)context
                    .getMergedJobDataMap().get(ScheduleJobEntity.JOB_PARAM_KEY);
            ThreadPoolTaskExecutor taskExecutor=SpringContextUtil.getBean("taskExecutor");
            //任务开始时间
            long startTime = System.currentTimeMillis();
            logger.info("我的任务准备执行，任务ID：" + scheduleJob.getJobId());
            try {
                /**
                 * ScheduleRunnable是一个任务类,通过反射执行真正的任务
                 */
                ScheduleRunnable task=new ScheduleRunnable(scheduleJob.getBeanName(),
                                      scheduleJob.getMethodName(),scheduleJob.getParams());
                Future<?> future=taskExecutor.submit(task);
                future.get();//线程结束之前下面语句不会执行
                long times=System.currentTimeMillis()-startTime;
                logger.info("我的任务执行完毕，任务ID：" + scheduleJob.getJobId() + "  总共耗时：" + times + "毫秒");
    
            } catch (Exception e) {
                logger.error("我的任务执行失败，任务ID：" + scheduleJob.getJobId(), e);
            }
        }
    }

定义任务类ScheduleRunnable，通过反射执行真正的任务

package com.fwone.utils;
    
    import org.apache.commons.lang.StringUtils;
    import org.springframework.util.ReflectionUtils;
    
    import java.lang.reflect.Method;
    
    /**
     * 执行定时任务
     * 
     * @author chenshun
     * @email sunlightcs@gmail.com
     * @date 2016年11月30日 下午12:49:33
     */
    public class ScheduleRunnable implements Runnable {
    	private Object target;//bean名称
    	private Method method;//bean的方法名称
    	private String params;//bean的参数
    
    	/**
    	 * 初始化
    	 * @param beanName
    	 * @param methodName
    	 * @param params
    	 * @throws NoSuchMethodException
    	 * @throws SecurityException
         */
    	public ScheduleRunnable(String beanName, String methodName, String params) throws NoSuchMethodException, SecurityException {
    		this.target = SpringContextUtil.getBean(beanName);
    		this.params = params;
    		
    		if(StringUtils.isNotBlank(params)){
    			this.method = target.getClass().getDeclaredMethod(methodName, String.class);
    		}else{
    			this.method = target.getClass().getDeclaredMethod(methodName);
    		}
    	}
    
    	@Override
    	public void run() {
    		try {
    			//让方法跳过安全检查
    			ReflectionUtils.makeAccessible(method);
    			if(StringUtils.isNotBlank(params)){
    				method.invoke(target, params);
    			}else{
    				method.invoke(target);
    			}
    		}catch (Exception e) {
    			throw new RRException("执行定时任务失败", e);
    		}
    	}
    
    }

最后，为了安全，还要在spring容器关闭时把调度器、线程池关闭。我试过如果不手动关闭，会发出警告说内存有可能溢出。

定义监听器，这样在容器关闭时能做一些处理工作.

package com.fwone.listener;
    
    
    import com.fwone.utils.RRException;
    import com.fwone.utils.SpringContextUtil;
    import org.quartz.Scheduler;
    import org.quartz.SchedulerException;
    
    import javax.servlet.ServletContextEvent;
    import javax.servlet.ServletContextListener;
    import javax.servlet.annotation.WebListener;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.TimeUnit;
    
    @WebListener
    public class MyContextLoaderListener implements ServletContextListener{
        @Override
        public void contextInitialized(ServletContextEvent sce) {
        }
    
        /**
         * 容器关闭时触发
         * @param sce
         */
        @Override
        public void contextDestroyed(ServletContextEvent sce) {
            /**
             * SpringContextUtil是我实现的一个获取bean的工具类,网上有很多例子,就不写出来了
             * 这里主要是把调度器Scheduler和线程池ExecutorService关闭
             */
            ExecutorService taskExecutor=SpringContextUtil.getBean("taskExecutor");
            Scheduler scheduler=(Scheduler)SpringContextUtil.getBean("scheduler");
            if(scheduler!=null){
                try {
                    if(scheduler.isStarted()){
                        scheduler.shutdown();
                    }
                } catch (SchedulerException e) {
                      throw new RRException("定时容器关闭失败");
                }
            }
            try {
                taskExecutor.shutdown();
                if(taskExecutor.awaitTermination(2000l, TimeUnit.MILLISECONDS))
                      taskExecutor.shutdownNow();
            }catch (InterruptedException e){
                e.printStackTrace();
                taskExecutor.shutdown();
            }
        }
    }

至此大功告成,以后想添加定时任务,只需把写好的bean名称传进去就可以了。