quartz定时任务解决service为空时的解决方案

最新推荐文章于 2025-03-02 17:49:22 发布

sun_falls

最新推荐文章于 2025-03-02 17:49:22 发布

阅读量1.1k

点赞数

分类专栏：定时任务-quartz 文章标签： quartz spring 解决方案

本文链接：https://blog.youkuaiyun.com/sun_falls/article/details/58586949

版权

定时任务-quartz 专栏收录该内容

1 篇文章

订阅专栏

本文介绍了一种不依赖Spring配置的Quartz定时任务实现方法，通过封装类简化定时任务的添加、修改和移除操作，并展示了如何在业务处理中使用这些方法。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

我们来处理定时任务的时候使用此种方式不需要进行spring配置，只需要引入quartz jar包和spring-quartz的包即可

首先是封装了定时任务的添加类

package com.supermap.wzhy.data;

import com.supermap.wzhy.module.fr.service.FrPushDataToMlkService;
import com.supermap.wzhy.module.fr.service.FrWjgService;
import com.supermap.wzhy.module.mlk.service.MlkPushDataToFrService;
import org.quartz.CronTrigger;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerFactory;
import org.quartz.impl.StdSchedulerFactory;

import java.util.Map;
import java.util.Set;

/**
 * Created by sun'fei on 17-2-21.
 */
public class QuartzManager {

    private static SchedulerFactory gSchedulerFactory = new StdSchedulerFactory();
    private static String JOB_GROUP_NAME = "WZHY_QUARTZ_JOB";
    private static String TRIGGER_GROUP_NAME = "WZHY_TRIGGER";

    /**
     * 添加一个定时任务，使用默认的任务组名，触发器名，触发器组名
     *
     * @param jobName
     *            任务名
     * @param jobClass
     *            任务
     * @param time
     *            时间设置，参考quartz说明文档
     */
    public static void addJob(String jobName, Class jobClass, String time,Map map,FrPushDataToMlkService service) {
        try {
            Scheduler sched = gSchedulerFactory.getScheduler();
            JobDetail jobDetail = new JobDetail(jobName, jobName, jobClass);// 任务名，任务组，任务执行类

            //传入参数
            if(!map.isEmpty()){
                Set set = map.keySet();
                Object [] key = set.toArray();
                for(int i = 0;i < key.length;i++){
                    jobDetail.getJobDataMap().put(key[i].toString(),map.get(key[i]));
                }
            }

            jobDetail.getJobDataMap().put("service",service);

            // 触发器
            // 调度器 调度当前定时任务执行命令
            CronTrigger trigger = new CronTrigger(jobName, TRIGGER_GROUP_NAME);// 触发器名,触发器组
            trigger.setCronExpression(time);// 触发器时间设定
            sched.scheduleJob(jobDetail, trigger);
            // 启动
            if (!sched.isShutdown()){
                sched.start();
            }
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }
    }

    public static void addMLkToFrkJob(String jobName, Class jobClass, String time,Map map,MlkPushDataToFrService service) {
        try {
            Scheduler sched = gSchedulerFactory.getScheduler();
            JobDetail jobDetail = new JobDetail(jobName, jobName, jobClass);// 任务名，任务组，任务执行类

            //传入参数
            if(!map.isEmpty()){
                Set set = map.keySet();
                Object [] key = set.toArray();
                for(int i = 0;i < key.length;i++){
                    jobDetail.getJobDataMap().put(key[i].toString(),map.get(key[i]));
                }
            }

            jobDetail.getJobDataMap().put("service",service);

            // 触发器 调度需要自动执行的任务
            CronTrigger trigger = new CronTrigger(jobName, TRIGGER_GROUP_NAME);// 触发器名,触发器组
            trigger.setCronExpression(time);// 触发器时间设定
            sched.scheduleJob(jobDetail, trigger);
            // 启动
            if (!sched.isShutdown()){
                sched.start();
            }
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }
    }

    public static void addFrToMlkJob(String jobName, Class jobClass, String time,Map map,FrPushDataToMlkService service) {
        try {
            Scheduler sched = gSchedulerFactory.getScheduler();
            JobDetail jobDetail = new JobDetail(jobName, jobName, jobClass);// 任务名，任务组，任务执行类

            //传入参数
            if(!map.isEmpty()){
                Set set = map.keySet();
                Object [] key = set.toArray();
                for(int i = 0;i < key.length;i++){
                    jobDetail.getJobDataMap().put(key[i].toString(),map.get(key[i]));
                }
            }

            jobDetail.getJobDataMap().put("service",service);

            // 触发器
            // 调度器 调度当前定时任务执行命令
            CronTrigger trigger = new CronTrigger(jobName, TRIGGER_GROUP_NAME);// 触发器名,触发器组
            trigger.setCronExpression(time);// 触发器时间设定
            sched.scheduleJob(jobDetail, trigger);
            // 启动
            if (!sched.isShutdown()){
                sched.start();
            }
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }
    }

    public static void addWjgJob(String jobName, Class jobClass, String time,Map map,FrWjgService service) {
        try {
            Scheduler sched = gSchedulerFactory.getScheduler();
            JobDetail jobDetail = new JobDetail(jobName, jobName, jobClass);// 任务名，任务组，任务执行类

            //传入参数
            if(!map.isEmpty()){
                Set set = map.keySet();
                Object [] key = set.toArray();
                for(int i = 0;i < key.length;i++){
                    jobDetail.getJobDataMap().put(key[i].toString(),map.get(key[i]));
                }
            }

            jobDetail.getJobDataMap().put("service",service);

            // 触发器
            // 调度器 调度当前定时任务执行命令
            CronTrigger trigger = new CronTrigger(jobName, TRIGGER_GROUP_NAME);// 触发器名,触发器组
            trigger.setCronExpression(time);// 触发器时间设定
            sched.scheduleJob(jobDetail, trigger);
            // 启动
            if (!sched.isShutdown()){
                sched.start();
            }
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }
    }

    /**
     * 添加一个定时任务
     *
     * @param jobName
     *            任务名
     * @param jobGroupName
     *            任务组名
     * @param triggerName
     *            触发器名
     * @param triggerGroupName
     *            触发器组名
     * @param jobClass
     *            任务
     * @param time
     *            时间设置，参考quartz说明文档
     */
    public static void addJob(String jobName, String jobGroupName,
                              String triggerName, String triggerGroupName, String jobClass, String time){
        try {
            Scheduler sched = gSchedulerFactory.getScheduler();
            JobDetail jobDetail = new JobDetail(jobName, jobGroupName, Class.forName(jobClass));// 任务名，任务组，任务执行类
            // 触发器
            CronTrigger trigger = new CronTrigger(triggerName, triggerGroupName);// 触发器名,触发器组
            trigger.setCronExpression(time);// 触发器时间设定
            sched.scheduleJob(jobDetail, trigger);
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }
    }

    /**
     * 修改一个任务的触发时间(使用默认的任务组名，触发器名，触发器组名)
     *
     * @param jobName
     * @param time
     */
    public static void modifyJobTime(String jobName, String time,FrPushDataToMlkService service) {
        try {
            Scheduler sched = gSchedulerFactory.getScheduler();
            CronTrigger trigger = (CronTrigger) sched.getTrigger(jobName, TRIGGER_GROUP_NAME);
            if(trigger == null) {
                return;
            }
            String oldTime = trigger.getCronExpression();
            if (!oldTime.equalsIgnoreCase(time)) {
                JobDetail jobDetail = sched.getJobDetail(jobName, JOB_GROUP_NAME);
                Class objJobClass = jobDetail.getJobClass();
                Map map = jobDetail.getJobDataMap();
                //String jobClass = objJobClass.getName();
                removeJob(jobName);

                addJob(jobName, objJobClass, time,map,service);
            }
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }
    }

    /**
     * 修改一个任务的触发时间
     *
     * @param triggerName
     * @param triggerGroupName
     * @param time
     */
    public static void modifyJobTime(String triggerName,
                                     String triggerGroupName, String time) {
        try {
            Scheduler sched = gSchedulerFactory.getScheduler();
            CronTrigger trigger = (CronTrigger) sched.getTrigger(triggerName, triggerGroupName);
            if(trigger == null) {
                return;
            }
            String oldTime = trigger.getCronExpression();
            if (!oldTime.equalsIgnoreCase(time)) {
                CronTrigger ct = (CronTrigger) trigger;
                // 修改时间
                ct.setCronExpression(time);
                // 重启触发器
                sched.resumeTrigger(triggerName, triggerGroupName);
            }
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }
    }

    /**
     * 移除一个任务(使用默认的任务组名，触发器名，触发器组名)
     *
     * @param jobName
     */
    public static String removeJob(String jobName) {
        try {
            Scheduler sched = gSchedulerFactory.getScheduler();
            sched.pauseTrigger(jobName, TRIGGER_GROUP_NAME);// 停止触发器
            sched.unscheduleJob(jobName, TRIGGER_GROUP_NAME);// 移除触发器
            sched.deleteJob(jobName, JOB_GROUP_NAME);// 删除任务
            System.out.println("已停止 "+jobName+" 定时任务");
            return "已停止 "+jobName+" 定时任务";
        } catch (Exception e) {
            System.out.println("停止 "+jobName+" 定时任务异常");
            e.printStackTrace();
            throw new RuntimeException(e);
        }
    }

    /**
     * 移除一个任务
     *
     * @param jobName
     * @param jobGroupName
     * @param triggerName
     * @param triggerGroupName
     */
    public static void removeJob(String jobName, String jobGroupName,
                                 String triggerName, String triggerGroupName) {
        try {
            Scheduler sched = gSchedulerFactory.getScheduler();
            sched.pauseTrigger(triggerName, triggerGroupName);// 停止触发器
            sched.unscheduleJob(triggerName, triggerGroupName);// 移除触发器
            sched.deleteJob(jobName, jobGroupName);// 删除任务
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }
    }

    /**
     * 启动所有定时任务
     */
    public static void startAllJobs() {
        try {
            Scheduler sched = gSchedulerFactory.getScheduler();
            sched.start();
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }
    }

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

}

然后我们进行业务处理的时候就可以使用QuartzManager里的add类型的方法注入service 如

package com.supermap.wzhy.module.sys.service;

import com.supermap.wzhy.data.QuartzManager;
import com.supermap.wzhy.data.SysConstant;
import com.supermap.wzhy.entity.TUsers;
import com.supermap.wzhy.module.fr.service.FrPushDataToMlkService;
import com.supermap.wzhy.module.fr.service.FrWjgService;
import com.supermap.wzhy.module.mlk.service.MlkPushDataToFrService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.servlet.http.HttpServletRequest;
import java.util.HashMap;
import java.util.Map;

/**
 * Created by Sun'fei on 17-2-19.
 */
@Service
public class QuartzTaskService{

    @Autowired
    FrPushDataToMlkService frPushDataToMlkService;

    @Autowired
    MlkPushDataToFrService mlkPushDataToFrService;

    @Autowired
    FrWjgService frWjgService;

    public boolean task(HttpServletRequest request,String mark,String time,
                        String tableCode,String tableName,String jobName){
        TUsers user = (TUsers)request.getSession().getAttribute(SysConstant.CURRENT_USER);
        String username = user.getUserName();
        Map map = new HashMap();
        map.put("username",username);
        //时间设置
        //String times = "0 0 "+time+" * * ?";
        String times = "0 5 * * * ?"; //测试 每五分执行一次
        if(mark != "wjg"){
            //quartz上下文参数
            map.put("tableCode",tableCode);
            map.put("tableName",tableName);

            System.out.println(jobName);
            if(mark == "frk"){
                QuartzManager.addFrToMlkJob(jobName, WZHYMLKJob.class, times, map,setFrPushDataToMlkServiceDao());
            }
            if(mark == "mlk"){
                QuartzManager.addMLkToFrkJob(jobName, WZHYFRKJob.class, times, map,setMlkPushDataToFrServiceDao());
            }
        }else{
            //System.out.println("定时任务表为空,执行文件柜导出！");
            QuartzManager.addWjgJob(jobName, WZHYWJGJob.class, times, map,setFrWjgServiceDao());
        }
        return true;
    }


    public FrPushDataToMlkService setFrPushDataToMlkServiceDao(){
        return this.frPushDataToMlkService;
    }

    public MlkPushDataToFrService setMlkPushDataToFrServiceDao(){
        return this.mlkPushDataToFrService;
    }
    public FrWjgService setFrWjgServiceDao(){
        return this.frWjgService;
    }

}

最后我们执行定时任务的时候就可以注入service了

package com.supermap.wzhy.module.sys.service;

import com.supermap.wzhy.module.mlk.service.MlkPushDataToFrService;
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.Map;

/**
 * Created by Sun'fei on 17-2-21.
 * 定时任务业务处理
 */
@Service
public class WZHYFRKJob implements Job {

    @Autowired
    MlkPushDataToFrService mlkPushDataToFrService;

    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Map map = jobExecutionContext.getMergedJobDataMap();
        String username = "";
        String tableCode = "";
        String tableName = "";
        if(!map.isEmpty()){
            username = map.get("username").toString();
            tableCode = map.get("tableCode").toString();
            tableName = map.get("tableName").toString();
        }

        mlkPushDataToFrService = (MlkPushDataToFrService)map.get("service");

        // 推送每天的增量数据 设置时间段
        Date date = new Date();
        //取当前时间
        String today = sdf.format(date);
        Calendar calendar = new GregorianCalendar();
        calendar.setTime(date);
        //把日期往前减少一天.整数往后推,负数往前移动
        calendar.add(calendar.DATE,-1);
        date = calendar.getTime();
        //取当前时间的前一天
        String yesterday = sdf.format(date);

        mlkPushDataToFrService.pushDataToFr(username, tableCode, tableName, yesterday, today);

    }
}

此方法亲测可行不必配置spring文件