java中基于线层池Spring-quartz如何实现动态增删除改和暂停恢复定时任务

• 攻略

技术java中基于线层池Spring-quartz如何实现动态增删除改和暂停恢复定时任务这篇文章主要讲解了“java中基于线层池Spring-quartz如何实现动态增删除改和暂停恢复定时任务”，文中的讲解内容简单清晰，

这篇文章主要讲解了“java中基于线层池弹簧石英如何实现动态增删除改和暂停恢复定时任务",文中的讲解内容简单清晰，易于学习与理解，下面请大家跟着小编的思路慢慢深入，一起来研究和学习“java中基于线层池弹簧石英如何实现动态增删除改和暂停恢复定时任务"吧！

注：本文中没有定时任务增删改查页面、保存数据库等操作的代码。根据实际需求自行完善

pom.xml

属国

groupIdorg.springframework/groupId

artifactIdspring-上下文-支持/artifactId

version4.2.5.RELEASE/version

/依赖性

属国

团体idog。石英调度程序/groupId

人工石英/人工石英

版本2 .2 .1/版本

/dependency spring-scheduler。可扩展标记语言

？xmlversion='1.0 '编码='UTF-8 '？

beans xmlns=' http://www。弹簧框架。“组织/架构/bean”

xmlns : xsi=' http://www。w3。org/2001/XMLSchema-instance ' xmlns : context=' http://www .弹簧框架。“组织/架构/上下文”

xsi :架构位置=' http://www。弹簧框架。org/schema/beans 3358 www .弹簧框架。org/schema/beans/spring-beans-4.2。xsd

http://www .弹簧框架。org/schema/context http://www弹簧框架。组织/模式/上下文/spring-context-4.2。xsd '

bean id=' schedulerFactoryBean ' class=' org。弹簧框架。日程安排。石英。schedulerfactory bean “/

/BeansAppLicationContext。XML(春季配置文件)

！-增加石英定时任务管理配置-

导入资源=' spring-scheduler。XML '/schedulejobmode。Java 语言(一种计算机语言，尤用于创建网站)

打包。调度程序；

导入Java。io。可序列化；

导入Java。乌提尔。日期；

/**

*定时任务方式

*/

public class schedulejobmodeimpactersessalizable {

privatedstationfinalloseriveversiuid=1L；

//任务调度参数键

publicationstatifindingjob _ PARAM _ KEY=' JOB _ PARAM _ KEY '；

    //任务id
    private String jobId;
    //spring bean名称 bean名称不能为空
    private String beanName;
    //方法名 方法名称不能为空 
    private String methodName;
    //参数
    private String params;
    //cron表达式
    private String cronExpression;
    //任务状态 1：正常，2：暂停
    private String status;
    //备注
    private String remark;
    //创建者
    private String createName;
    //创建时间
    private Date createTime;
    //最近更新人
    private String modifierName;
    //最近更新时间
    private Date modifierTime;
    public void setJobId(String jobId) {
        this.jobId = jobId;
    }
    public String getJobId() {
        return jobId;
    }
    public String getBeanName() {
        return beanName;
    }
    public void setBeanName(String beanName) {
        this.beanName = beanName;
    }
    public String getMethodName() {
        return methodName;
    }
    public void setMethodName(String methodName) {
        this.methodName = methodName;
    }
    public String getParams() {
        return params;
    }
    public void setParams(String params) {
        this.params = params;
    }
    public String getRemark() {
        return remark;
    }
    public void setRemark(String remark) {
        this.remark = remark;
    }
    public void setStatus(String status) {
        this.status = status;
    }
    public String getStatus() {
        return status;
    }
    public void setCronExpression(String cronExpression) {
        this.cronExpression = cronExpression;
    }
    public String getCronExpression() {
        return cronExpression;
    }
    public void setCreateTime(Date createTime) {
        this.createTime = createTime;
    }
    public Date getCreateTime() {
        return createTime;
    }
    public String getCreateName() {
        return createName;
    }
    public void setCreateName(String createName) {
        this.createName = createName;
    }
    public String getModifierName() {
        return modifierName;
    }
    public void setModifierName(String modifierName) {
        this.modifierName = modifierName;
    }
    public Date getModifierTime() {
        return modifierTime;
    }
    public void setModifierTime(Date modifierTime) {
        this.modifierTime = modifierTime;
    }
}

ScheduleJobLogMode.java

package com.scheduler;
import java.io.Serializable;
import java.util.Date;
/**
 * 定时执行日志
 */
public class ScheduleJobLogMode implements Serializable {
    private static final long serialVersionUID = 1L;
    //日志id
    private String logId;
    //任务id
    private String jobId;
    //spring bean名称
    private String beanName;
    //方法名
    private String methodName;
    //参数
    private String params;
    //任务状态    0：成功    1：失败
    private String status;
    //失败信息
    private String error;
    //耗时(单位：毫秒)
    private Integer times;
    //创建时间
    private Date createTime;
    public String getLogId() {
        return logId;
    }
    public void setLogId(String logId) {
        this.logId = logId;
    }
    public String getJobId() {
        return jobId;
    }
    public void setJobId(String jobId) {
        this.jobId = jobId;
    }
    public String getBeanName() {
        return beanName;
    }
    public void setBeanName(String beanName) {
        this.beanName = beanName;
    }
    public String getMethodName() {
        return methodName;
    }
    public void setMethodName(String methodName) {
        this.methodName = methodName;
    }
    public String getParams() {
        return params;
    }
    public void setParams(String params) {
        this.params = params;
    }
    public String getStatus() {
        return status;
    }
    public void setStatus(String status) {
        this.status = status;
    }
    public String getError() {
        return error;
    }
    public void setError(String error) {
        this.error = error;
    }
    public Integer getTimes() {
        return times;
    }
    public void setTimes(Integer times) {
        this.times = times;
    }
    public Date getCreateTime() {
        return createTime;
    }
    public void setCreateTime(Date createTime) {
        this.createTime = createTime;
    }
}

ScheduleUtils.java

package com.scheduler;
import com.wawj.fg.common.scheduler.ScheduleJob;
import com.wawj.fg.common.scheduler.support.TaskSupport;
import com.scheduler.ScheduleJobMode;
import org.quartz.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
 * 定时任务工具类
 */
public class ScheduleUtils {
    private static final Logger logger = LoggerFactory.getLogger(ScheduleUtils.class);
    private static final String JOB_NAME = "TASK_";
    /**
     * 获取触发器key
     */
    public static TriggerKey getTriggerKey(String jobId) {
        return TriggerKey.triggerKey(JOB_NAME + jobId);
    }
    /**
     * 获取jobKey
     */
    public static JobKey getJobKey(String jobId) {
        return JobKey.jobKey(JOB_NAME + jobId);
    }
    /**
     * 获取表达式触发器
     */
    public static CronTrigger getCronTrigger(Scheduler scheduler, String jobId) {
        try {
            return (CronTrigger) scheduler.getTrigger(getTriggerKey(jobId));
        } catch (SchedulerException e) {
            logger.info("获取定时任务CronTrigger出现异常", e);
            return null;
        }
    }
    /**
     * 创建定时任务
     */
    public static void createScheduleJob(Scheduler scheduler, ScheduleJobMode scheduleJob) {
        try {
            //构建job信息
            JobDetail jobDetail = JobBuilder.newJob(ScheduleJob.class).withIdentity(getJobKey(scheduleJob.getJobId())).build();
            //表达式调度构建器
            CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(scheduleJob.getCronExpression())
                    .withMisfireHandlingInstructionDoNothing();
            //按新的cronExpression表达式构建一个新的trigger
            CronTrigger trigger = TriggerBuilder.newTrigger().withIdentity(getTriggerKey(scheduleJob.getJobId())).withSchedule(scheduleBuilder).build();
            //放入参数，运行时的方法可以获取
            jobDetail.getJobDataMap().put(ScheduleJobMode.JOB_PARAM_KEY, scheduleJob);
            scheduler.scheduleJob(jobDetail, trigger);
            //暂停任务
            if (scheduleJob.getStatus().equals(TaskSupport.TASK_STATUS_STOPPED)) {
                pauseJob(scheduler, scheduleJob.getJobId());
            }
        } catch (SchedulerException e) {
            logger.info("创建定时任务失败", e);
        }
    }
    /**
     * 更新定时任务
     */
    public static void updateScheduleJob(Scheduler scheduler, ScheduleJobMode scheduleJob) {
        try {
            TriggerKey triggerKey = getTriggerKey(scheduleJob.getJobId());
            //表达式调度构建器
            CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(scheduleJob.getCronExpression())
                    .withMisfireHandlingInstructionDoNothing();
            CronTrigger trigger = getCronTrigger(scheduler, scheduleJob.getJobId());
            if (null != trigger) {
                //按新的cronExpression表达式重新构建trigger
                trigger = trigger.getTriggerBuilder().withIdentity(triggerKey).withSchedule(scheduleBuilder).build();
                //参数
                trigger.getJobDataMap().put(ScheduleJobMode.JOB_PARAM_KEY, scheduleJob);
                scheduler.rescheduleJob(triggerKey, trigger);
                //暂停任务
                if (scheduleJob.getStatus().equals(TaskSupport.TASK_STATUS_STOPPED)) {
                    pauseJob(scheduler, scheduleJob.getJobId());
                }
            } else {
                throw new NullPointerException();
            }
        } catch (SchedulerException e) {
            logger.info("更新定时任务失败", e);
        }
    }
    /**
     * 立即执行任务
     */
    public static void run(Scheduler scheduler, ScheduleJobMode scheduleJob) {
        try {
            //参数
            JobDataMap dataMap = new JobDataMap();
            dataMap.put(ScheduleJobMode.JOB_PARAM_KEY, scheduleJob);
            scheduler.triggerJob(getJobKey(scheduleJob.getJobId()), dataMap);
        } catch (SchedulerException e) {
            logger.info("立即执行定时任务失败", e);
        }
    }
    /**
     * 暂停任务
     */
    public static void pauseJob(Scheduler scheduler, String jobId) {
        try {
            scheduler.pauseJob(getJobKey(jobId));
        } catch (SchedulerException e) {
            logger.info("暂停定时任务失败", e);
        }
    }
    /**
     * 恢复任务
     */
    public static void resumeJob(Scheduler scheduler, String jobId) {
        try {
            scheduler.resumeJob(getJobKey(jobId));
        } catch (SchedulerException e) {
            logger.info("暂停定时任务失败", e);
        }
    }
    /**
     * 删除定时任务
     */
    public static void deleteScheduleJob(Scheduler scheduler, String jobId) {
        try {
            scheduler.deleteJob(getJobKey(jobId));
        } catch (SchedulerException e) {
            logger.info("删除定时任务失败", e);
        }
    }
}

QuartzManager.java

package com.scheduler;
import com.wawj.fg.common.scheduler.ScheduleUtils;
import com.wawj.fg.model.baseinfo.scheduler.ScheduleJobMode;
import org.quartz.CronTrigger;
import org.quartz.Scheduler;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;
import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;
import java.util.HashMap;
import java.util.List;
@Component
public class QuartzManager {
    @Autowired
    private SchedulerFactoryBean schedulerFactoryBean;
    /**
     * 项目启动时，初始化定时器
     */
    @PostConstruct
    public void init() {
        //查询保存到数据的定时任务，本文没有操作数据代码，可自行完善
        List<ScheduleJobMode> scheduleJobList = schedulerJobDao.queryList(new HashMap<String, Object>());
        Scheduler scheduler = schedulerFactoryBean.getScheduler();
        for (ScheduleJobMode scheduleJob : scheduleJobList) {
            CronTrigger cronTrigger = ScheduleUtils.getCronTrigger(scheduler, scheduleJob.getJobId());
            //如果不存在，则创建
            if (cronTrigger == null) {
                ScheduleUtils.createScheduleJob(scheduler, scheduleJob);
            } else {
                ScheduleUtils.updateScheduleJob(scheduler, scheduleJob);
            }
        }
    }
    /**
     * 创建定时器
     */
    public void createScheduleJob(ScheduleJobMode scheduleJob) {
        Scheduler scheduler = schedulerFactoryBean.getScheduler();
        ScheduleUtils.createScheduleJob(scheduler, scheduleJob);
    }
    /**
     * 更新定时器
     */
    public void update(ScheduleJobMode scheduleJob) {
        Scheduler scheduler = schedulerFactoryBean.getScheduler();
        ScheduleUtils.updateScheduleJob(scheduler, scheduleJob);
    }
    /**
     * 删除定时器
     */
    public void deleteBatch(String[] jobIds) {
        Scheduler scheduler = schedulerFactoryBean.getScheduler();
        for (String jobId : jobIds) {
            ScheduleUtils.deleteScheduleJob(scheduler, jobId);
        }
    }
    /**
     * 立刻执行一下定时器
     */
    public void run(String[] jobIds) {
        Scheduler scheduler = schedulerFactoryBean.getScheduler();
        for (String jobId : jobIds) {
            //queryObject(jobId) 是从数据库中查询出对象
            ScheduleUtils.run(scheduler, queryObject(jobId));
        }
    }
    /**
     * 暂停定时任务
     */
    public void pause(String[] jobIds) {
        Scheduler scheduler = schedulerFactoryBean.getScheduler();
        for (String jobId : jobIds) {
            ScheduleUtils.pauseJob(scheduler, jobId);
        }
    }
    /**
     * 恢复定时任务
     */
    public void resume(String[] jobIds) {
        Scheduler scheduler = schedulerFactoryBean.getScheduler();
        for (String jobId : jobIds) {
            ScheduleUtils.resumeJob(scheduler, jobId);
        }
    }
}

SpringUtils.java

package com.scheduler;
import com.wawj.fg.util.SpringContextUtils;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;
/**
 * Spring Context 工具类
 */
@Component
public class SpringUtils implements ApplicationContextAware {
    private static ApplicationContext applicationContext;
    @Override
    public void setApplicationContext(ApplicationContext applicationContext)
            throws BeansException {
        SpringContextUtils.applicationContext = applicationContext;
    }
    public static Object getBean(String name) {
        return applicationContext.getBean(name);
    }
    public static <T> T getBean(String name, Class<T> requiredType) {
        return applicationContext.getBean(name, requiredType);
    }
    public static boolean containsBean(String name) {
        return applicationContext.containsBean(name);
    }
    public static boolean isSingleton(String name) {
        return applicationContext.isSingleton(name);
    }
    public static Class<? extends Object> getType(String name) {
        return applicationContext.getType(name);
    }
}

ScheduleRunnable.java

package com.scheduler;
import java.lang.reflect.Method;
import org.apache.commons.lang.StringUtils;
import org.apache.log4j.Logger;
import org.springframework.util.ReflectionUtils;
import com.scheduler;.SpringUtils;
/**
 * 执行定时任务
 */
public class ScheduleRunnable implements Runnable {
	private static final Logger logger = Logger.getLogger(ScheduleRunnable.class);
    //类名
	private Object target;
    //方法名
	private Method method;
    //参数
	private String params;
	
	public ScheduleRunnable(String beanName, String methodName, String params) throws NoSuchMethodException{
		this.target = SpringUtils.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) {
			logger.error("执行定时任务失败",e);
			throw new RuntimeException();
		}
	}
}

ScheduleJob.java

package com.scheduler;
import com.wawj.fg.common.scheduler.ScheduleRunnable;
import com.wawj.fg.model.baseinfo.scheduler.ScheduleJobLogMode;
import com.wawj.fg.model.baseinfo.scheduler.ScheduleJobMode;
import com.wawj.fg.service.baseinfo.scheduler.ScheduleJobLogService;
import com.wawj.fg.util.SpringContextUtils;
import com.wawj.fg.util.UUIDUtil;
import org.apache.log4j.Logger;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.scheduling.quartz.QuartzJobBean;
import java.util.Date;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
/**
 * 定时任务
 */
public class ScheduleJob extends QuartzJobBean {
    private static final Logger logger = Logger.getLogger(ScheduleJob.class);
    //创建线层池 （创建一个单线程化的线程池）
    private ExecutorService service = Executors.newSingleThreadExecutor();
    @Override
    protected void executeInternal(JobExecutionContext context) throws JobExecutionException {
        ScheduleJobMode scheduleJob = (ScheduleJobMode) context.getMergedJobDataMap()
                .get(ScheduleJobMode.JOB_PARAM_KEY);
        //获取spring bean
        ScheduleJobLogService scheduleJobLogService = (ScheduleJobLogService) SpringContextUtils.getBean("scheduleJobLogService");
        //数据库保存执行记录
        ScheduleJobLogMode log = new ScheduleJobLogMode();
        log.setLogId(UUIDUtil.getUUID());
        log.setJobId(scheduleJob.getJobId());
        log.setBeanName(scheduleJob.getBeanName());
        log.setMethodName(scheduleJob.getMethodName());
        log.setParams(scheduleJob.getParams());
        log.setCreateTime(new Date());
        //任务开始时间
        long startTime = System.currentTimeMillis();
        try {
            //执行任务
            logger.info("任务准备执行，任务ID：" + scheduleJob.getJobId());
            ScheduleRunnable task = new ScheduleRunnable(scheduleJob.getBeanName(),
                    scheduleJob.getMethodName(), scheduleJob.getParams());
            Future<?> future = service.submit(task);
            future.get();
            //任务执行总时长
            long times = System.currentTimeMillis() - startTime;
            log.setTimes((int) times);
            //任务状态    0：成功    1：失败
            log.setStatus("0");
            logger.info("任务执行完毕，任务ID：" + scheduleJob.getJobId() + "  总共耗时：" + times + "毫秒");
        } catch (Exception e) {
            logger.error("任务执行失败，任务ID：" + scheduleJob.getJobId(), e);
            //任务执行总时长
            long times = System.currentTimeMillis() - startTime;
            log.setTimes((int) times);
            //任务状态    0：成功    1：失败
            log.setStatus("1");
            log.setError(scheduleJob.getBeanName() + "." + scheduleJob.getMethodName());
        } finally {
            scheduleJobLogService.save(log);
        }
    }
}

感谢各位的阅读，以上就是“java中基于线层池Spring-quartz如何实现动态增删除改和暂停恢复定时任务”的内容了，经过本文的学习后，相信大家对java中基于线层池Spring-quartz如何实现动态增删除改和暂停恢复定时任务这一问题有了更深刻的体会，具体使用情况还需要大家实践验证。这里是，小编将为大家推送更多相关知识点的文章，欢迎关注！

内容来源网络，如有侵权，联系删除，本文地址：https://www.230890.com/zhan/93203.html

赞 (0)

相关推荐

  • ogg 进程开启前的数据怎么同步(ogg捕获dml)

    技术OGG双向DML复制怎么实现本篇内容主要讲解“OGG双向DML复制怎么实现”，感兴趣的朋友不妨来看看。本文介绍的方法操作简单快捷，实用性强。下面就让小编来带大家学习“OGG双向DML复制怎么实现”吧!环境解释：hos

    攻略 2021年12月22日

  • MySQL有什么用

    技术MySQL有什么用小编给大家分享一下MySQL有什么用，相信大部分人都还不怎么了解，因此分享这篇文章给大家参考一下，希望大家阅读完这篇文章后大有收获，下面让我们一起去了解一下吧！MySQL简介MySQL是一款流行的开

    攻略 2021年11月18日

  • 为什么代理IP让网络爬虫更快速抓取数据

    技术为什么代理IP让网络爬虫更快速抓取数据本篇文章为大家展示了为什么代理IP让网络爬虫更快速抓取数据，内容简明扼要并且容易理解，绝对能使你眼前一亮，通过这篇文章的详细介绍希望你能有所收获。如今，很多人每天的工作都要与网络

    攻略 2021年10月28日

  • mr on yarn架构

    技术mr on yarn架构 mr on yarn架构提交作业①程序打成jar包，在客户端运行hadoop jar命令，提交job到集群运行job.waitForCompletion(true)中调用J

    礼包 2021年12月3日

  • 黑眼圈,快速去除黑眼圈的好方法有哪些

    技术黑眼圈,快速去除黑眼圈的好方法有哪些黑眼圈的形成原因比较复杂，总体可以按照成因分为以下2类黑眼圈：1、色素沉积型：一般为茶褐色，多由于日晒、不恰当的化妆和卸妆等导致的皮肤色素沉着。解决对策上应以减少色素沉积、促进黑色

    生活 2021年10月20日

  • javascript条件式访问属性和箭头函数的示例分析

    技术javascript条件式访问属性和箭头函数的示例分析这篇文章主要介绍了javascript条件式访问属性和箭头函数的示例分析，具有一定借鉴价值，感兴趣的朋友可以参考下，希望大家阅读完这篇文章之后大有收获，下面让小编

    攻略 2021年11月14日