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)

相关推荐

  • 设计模式-观察者模式(java)

    技术设计模式-观察者模式(java) 设计模式-观察者模式(java)当股票的价格上涨或下降5%时，会通知持有该股票的股民，当股民听到价格上涨的消息时会买股票，当价格下降时会大哭一场。
    类图public

    礼包 2021年11月20日

  • Solr4.7突出显示的方法是什么？

    技术solr4.7高亮显示方法是什么这篇文章主要讲解了“solr4.7高亮显示方法是什么”，文中的讲解内容简单清晰，易于学习与理解，下面请大家跟着小编的思路慢慢深入，一起来研究和学习“solr4.7高亮显示方法是什么”吧

    攻略 2021年12月22日

  • Viper FTP怎么用

    技术Viper FTP怎么用今天就跟大家聊聊有关Viper FTP怎么用，可能很多人都不太了解，为了让大家更加了解，小编给大家总结了以下内容，希望大家根据这篇文章可以有所收获。Viper FTP是一款Mac平台上功能强大

    攻略 2021年11月20日

  • Maven下载后配置

    技术Maven下载后配置 Maven下载后配置settings.xml配置文件路径
    如：E:\apache-maven-3.8.3\conf\settings.xml设置本地库路径Windows默认为C

    礼包 2021年11月13日

  • MySQL中行转列、列转行、连接字符串 concat、concat_ws、group_concat函数怎么用

    技术MySQL中行转列、列转行、连接字符串 concat、concat_ws、group_concat函数怎么用这篇文章主要介绍MySQL中行转列、列转行、连接字符串 concat、concat_ws、group_c

    攻略 2021年10月29日
  • 狗狗感冒了会自己好吗,狗狗感冒了,吃感冒冲剂能好吗 生活

    狗狗感冒了会自己好吗,狗狗感冒了,吃感冒冲剂能好吗

    技术狗狗感冒了会自己好吗,狗狗感冒了,吃感冒冲剂能好吗狗狗感冒在天气忽冷忽热的时候比较多见，如果狗狗不小心着凉感冒，特别是在天气忽冷忽热的时候，或者是比较冷的天气里总是趴在冰冷的地板上，一着凉感冒就会出现打喷嚏、流鼻涕等

    2021年10月20日