定时任务（三）动态配置定时任务

最新推荐文章于 2024-06-21 16:46:24 发布
最新推荐文章于 2024-06-21 16:46:24 发布
阅读量772 收藏
点赞数
文章标签： quartz java spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43399870/article/details/109053738
版权

第二篇我们主要介绍了Quartz引入Spring框架的基本配置,这一篇直接开始对定时任务进行动态操控

一、 创建相关实体类

（1）定时任务参数在这里插入图片描述
（2）存储TriggerName 的类，主要用来防重
在这里插入图片描述
（3）定时任务参数类的请求与返回
在这里插入图片描述
（4）调用任务实体类

package com.test.pojo.job;

import java.lang.reflect.Method;

import org.quartz.DisallowConcurrentExecution;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.scheduling.quartz.QuartzJobBean;

/**
 * 功能说明：任务实体类<br>
 * 注意事项：<br>
 * 系统版本：version 1.0<br>
 * 开发人员：renzw26782<br>
 * 开发时间：2020年8月3日<br>
 */
@DisallowConcurrentExecution
public class QuartzJob extends QuartzJobBean {

	private static final Logger logger = LoggerFactory.getLogger(QuartzJob.class);

	private UseJobDto useJobDto;

	protected void executeInternal(JobExecutionContext context) throws JobExecutionException {

		// 调用余额对账定时服务
		this.execute(useJobDto.getFunctionId());

	}

	public UseJobDto getUseJobDto() {
		return useJobDto;
	}

	public void setUseJobDto(UseJobDto useJobDto) {
		this.useJobDto = useJobDto;
	}

	private void execute(String url) {
		try {
			if (logger.isDebugEnabled()) {
				logger.debug("调用服务[" + url + "]调用开始!");
			}
			String[] arr = url.split("#");
			String useJobMethod = arr[1].trim();
			// 通过反射调用服务
			String useJob = arr[0].trim();
			String useJobName = useJob.substring(0, 1).toUpperCase() + useJob.substring(1);
			@SuppressWarnings("rawtypes")
			Class c = Class.forName("com.test.job." + useJobName);
			Object obj = c.newInstance();
			Method jobMethod = obj.getClass().getMethod(useJobMethod);
			jobMethod.invoke(obj);
			System.out.println("执行成功");
		} catch (Exception e) {
			logger.debug("调用服务[" + url + "]失败", e);
			System.out.println("执行失败");
		} finally {
			if (logger.isDebugEnabled()) {
				logger.debug("调用服务[" + url + "]调用结束!");
			}
		}

	}

}
二、 各处理层逻辑处理

直接上代码吧
（1）controller控制层

package com.test.controller.job;

import java.util.List;

import org.apache.maven.surefire.shade.org.apache.maven.shared.utils.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import com.test.enums.UseJobExecutePathEnum;
import com.test.enums.UseJobStatusEnum;
import com.test.pojo.job.BaseResp;
import com.test.pojo.job.UseJob;
import com.test.pojo.job.UseJobReq;
import com.test.pojo.job.UseJobResp;
import com.test.service.common.CommonService;
import com.test.service.job.UseJobService;

@Controller
@RequestMapping(value = "/useJop")
public class UseJobController {

	@ModelAttribute
	protected void initData(Model model) {
		// 1、定时任务状态
		model.addAttribute("useJobStatusMap", UseJobStatusEnum.toMap());
		model.addAttribute("useJobExecutePathMap", UseJobExecutePathEnum.toMap());
		model.addAttribute("aaa", "111");
	}

	@RequestMapping(value = "/toJobPage")
	public String totoJobPage() {
		return "WEB-INF/job/jobPage";
	}

	@RequestMapping(value = "/addJobPage")
	public String toAddJobPage(UseJob useJob, Model model) {
		if (useJob != null && StringUtils.isNotBlank(useJob.getJobId())) {
			UseJobReq req = new UseJobReq(useJob);
			UseJobResp resp = useJobService.getUseJodInfoById(req);
			model.addAttribute("job", resp.getItem());
		}
		return "WEB-INF/job/addJobPage";
	}

	@Autowired
	private UseJobService useJobService;

	@Autowired
	CommonService commonService;

	@RequestMapping(value = "/queryJobList.do")
	@ResponseBody
	public List<UseJob> queryUseJobList(String jobName, String jobState) {
		UseJob job = new UseJob();

		if (StringUtils.isBlank(jobState)
				|| StringUtils.equals(jobState.trim(), UseJobStatusEnum.PLEASE_SELECT.getCode())) {
			job.setJobState("");
		} else {
			job.setJobState(jobState.trim());
		}
		if (StringUtils.isBlank(jobName)) {
			job.setJobName("");
		} else {
			job.setJobName(jobName.trim());
		}
		UseJobReq useJobReq = new UseJobReq(job);
		UseJobResp useJobResp = null;
		useJobResp = useJobService.queryUseJobList(useJobReq);
		return useJobResp.getItems();

	}

	@RequestMapping("/addUseJob.do")
	@ResponseBody
	public void addUseJob(UseJob useJob) {
		UseJobReq req = new UseJobReq(useJob);
		BaseResp baseResp = null;
		if (StringUtils.isBlank(useJob.getJobId())) {
			Long nowDate = commonService.getNowDate();
			Long nowTime = commonService.getNowTime();
			useJob.setJobId(nowDate.toString() + nowTime.toString());
			baseResp = useJobService.addUseJob(req);
		} else {
			baseResp = useJobService.updateUseJob(req);
		}

	}

	/**
	 * 启动定时任务
	 * 
	 * @param info
	 * @return
	 */
	@RequestMapping("/startJob.do")
	@ResponseBody
	public String startUseJob(String jobId, String functionId) {
		UseJob object = new UseJob();
		object.setFunctionId(functionId);
		object.setJobId(jobId);
		UseJobReq req = new UseJobReq(object);
		BaseResp resp = useJobService.startUseJob(req);
		String message = "启动任务成功";
		if (resp.getErrorNo() != 0) {
			message = "启动任务失败" + resp.getErrorInfo();
		}
		return message;
	}

	/**
	 * 启动定时任务
	 * 
	 * @param info
	 * @return
	 */
	@RequestMapping("/stopJob.do")
	@ResponseBody
	public String stopUseJob(String jobId, String functionId) {
		UseJob object = new UseJob();
		object.setFunctionId(functionId);
		object.setJobId(jobId);
		UseJobReq req = new UseJobReq(object);
		BaseResp resp = useJobService.stopUseJob(req);
		String message = "启动任务成功";
		if (resp.getErrorNo() != 0) {
			message = "启动任务失败" + resp.getErrorInfo();
		}
		return message;
	}

	/**
	 * 删除定时任务
	 * 
	 * @param info
	 * @return
	 */
	@RequestMapping("/delJob.do")
	@ResponseBody
	public String delUseJob(String jobId, String functionId) {
		UseJob object = new UseJob();
		object.setFunctionId(functionId);
		object.setJobId(jobId);
		UseJobReq req = new UseJobReq(object);
		BaseResp resp = useJobService.delUseJob(req);
		String message = "删除任务成功";
		if (resp.getErrorNo() != 0) {
			message = "删除任务失败" + resp.getErrorInfo();
		}
		return message;
	}

}

(2) service服务层

package com.test.service.job;

import java.util.List;

import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.test.logic.job.UseJobLogic;
import com.test.pojo.job.BaseResp;
import com.test.pojo.job.UseJob;
import com.test.pojo.job.UseJobDto;
import com.test.pojo.job.UseJobReq;
import com.test.pojo.job.UseJobResp;
import com.test.utils.BeanUtils;
import com.test.utils.StringUtils;

@Service("jobFactory")
public class UseJobServiceImpl implements UseJobService {
	private Logger logger = Logger.getLogger(UseJobServiceImpl.class);

	@Autowired
	private UseJobLogic useJobLogic;

	@Override
	public UseJobResp queryUseJobList(UseJobReq req) {

		UseJobResp resp = new UseJobResp();
		List<UseJob> ls = null;
		try {
			ls = useJobLogic.queryJobs(req.getObject());
		} catch (Exception e) {
			resp.setErrorId("999999");
			resp.setErrorInfo("查询定时任务失败，请联系相关技术人员！");
		}
		resp.setItems(ls);
		return resp;

	}

	@Override
	public BaseResp addUseJob(UseJobReq req) {
		BaseResp resp = new BaseResp();
		UseJobDto job = new UseJobDto();
		try {
			UseJob object = req.getObject();
			BeanUtils.copyProperties(job, object);
			// 1-参数校验
			resp = validateJobDto(job);
			if (resp.getErrorNo() > 0) {
				return resp;
			}

			// 2-校验任务是否存在

			if (useJobLogic.isExistJob(job)) {
				resp.setErrorNo(999999);
				resp.setErrorInfo("待新增的任务已存在");
				return resp;
			}

			// 2-添加任务
			useJobLogic.addJob(job);
			// 记录操作日志
			try {
			} catch (Exception e) {

			}
		} catch (Exception e) {
			resp.setErrorNo(999999);
			resp.setErrorInfo("新增定时任务失败，请联系相关技术人员！");
			logger.error(resp.getErrorInfo(), e);
		}
		return resp;

	}

	/**
	 * 描述：校验入参<br>
	 * 参数：@param job 参数：@return<br>
	 * 返回值：BaseResp<br>
	 * 
	 * @throws Exception
	 */
	private BaseResp validateJobDto(UseJobDto job) throws Exception {
		BaseResp resp = new BaseResp();
		if (job == null) {
			resp.setErrorNo(999999);
			resp.setErrorInfo("任务对象不能为空");
			return resp;
		}

		if (StringUtils.isBlank(job.getJobId())) {
			resp.setErrorNo(999999);
			resp.setErrorInfo("批次信息不能为空");
			return resp;
		}

		if (StringUtils.isBlank(job.getFunctionId())) {
			resp.setErrorNo(999999);
			resp.setErrorInfo("服务路径不能为空");
			return resp;
		}

		if (StringUtils.isBlank(job.getJobName())) {
			resp.setErrorNo(999999);
			resp.setErrorInfo("任务名称不能为空");
			return resp;
		}

		if (StringUtils.isBlank(job.getExpression())) {
			resp.setErrorNo(999999);
			resp.setErrorInfo("时间间隔表达式不能为空");
			return resp;
		}

		return resp;
	}

	@Override
	public BaseResp startUseJob(UseJobReq req) {

		BaseResp resp = new BaseResp();
		UseJobDto job = new UseJobDto();
		try {
			UseJob object = req.getObject();
			BeanUtils.copyProperties(job, object);

			// 1-校验任务是否存在
			if (!useJobLogic.isExistJob(job)) {
				resp.setErrorNo(999999);
				resp.setErrorInfo("该任务不存在");
				return resp;
			}

			if (!useJobLogic.isPausedJob(job)) {
				return resp;
			}
			useJobLogic.startUseJob(job);

		} catch (Exception e) {
			resp.setErrorNo(999999);
			resp.setErrorInfo("启动定时任务失败，请联系相关技术人员！");
			logger.error(resp.getErrorInfo(), e);
		}
		return resp;

	}

	@Override
	public BaseResp stopUseJob(UseJobReq req) {
		BaseResp resp = new BaseResp();
		UseJobDto job = new UseJobDto();
		try {
			UseJob object = req.getObject();
			BeanUtils.copyProperties(job, object);

			// 1-校验任务是否存在
			if (!useJobLogic.isExistJob(job)) {
				resp.setErrorNo(999999);
				resp.setErrorInfo("该任务不存在");
				return resp;
			}

			if (useJobLogic.isPausedJob(job)) {
				return resp;
			}
			useJobLogic.stopUseJob(job);
			// 记录操作日志

		} catch (Exception e) {
			resp.setErrorNo(999999);
			resp.setErrorInfo("暂停定时任务失败，请联系相关技术人员！");
			logger.error(resp.getErrorInfo(), e);
		}
		return resp;
	}

	@Override
	public BaseResp delUseJob(UseJobReq req) {
		BaseResp resp = new BaseResp();
		UseJobDto job = new UseJobDto();
		try {
			UseJob object = req.getObject();
			BeanUtils.copyProperties(job, object);
			// 1-校验任务是否存在
			if (!useJobLogic.isExistJob(job)) {
				resp.setErrorNo(999999);
				resp.setErrorInfo("所删除的任务不存在");
				return resp;
			}

			// 2-校验当前任务状态是否是暂停状态
			if (!useJobLogic.isPausedJob(job)) {
				resp.setErrorNo(999999);
				resp.setErrorInfo("所删除的任务必须处于暂停状态");
				return resp;
			}

			// 3-删除任务
			useJobLogic.deleteJob(job);
			// 记录操作日志

		} catch (Exception e) {
			resp.setErrorNo(999999);
			resp.setErrorInfo("删除定时任务失败，请联系相关技术人员！");
			logger.error(resp.getErrorInfo(), e);
		}
		return resp;
	}

	@Override
	public UseJobResp getUseJodInfoById(UseJobReq req) {

		UseJobResp resp = new UseJobResp();
		UseJobDto job = new UseJobDto();
		try {
			UseJob object = req.getObject();
			BeanUtils.copyProperties(job, object);
			// 1-校验任务是否存在
			if (!useJobLogic.isExistJob(job)) {
				resp.setErrorNo(999999);
				resp.setErrorInfo("所查看的任务不存在");
				return resp;
			}
			// 2-添加任务
			UseJob item = useJobLogic.getUseJodInfo(job);
			resp.setItem(item);
		} catch (Exception e) {
			resp.setErrorNo(999999);
			resp.setErrorInfo("查看定时任务失败，请联系相关技术人员！");
			logger.error(resp.getErrorInfo(), e);
		}

		return resp;

	}

	@Override
	public BaseResp updateUseJob(UseJobReq req) {
		BaseResp resp = new BaseResp();
		UseJobDto job = new UseJobDto();
		try {
			UseJob object = req.getObject();
			BeanUtils.copyProperties(job, object);
			// 1-参数校验
			resp = validateJobDto(job);
			if (resp.getErrorNo() > 0) {
				return resp;
			}

			// 2-校验任务是否存在
			if (!useJobLogic.isExistJob(job)) {
				resp.setErrorNo(999999);
				resp.setErrorInfo("所修改的任务不存在");
				return resp;
			}

			// 3-校验当前任务状态是否是暂停状态
			if (!useJobLogic.isPausedJob(job)) {
				resp.setErrorNo(999999);
				resp.setErrorInfo("所修改的任务必须处于暂停状态");
				return resp;
			}

			// 4-修改任务
			useJobLogic.updateJob(job);
			// 记录操作日志

		} catch (Exception e) {
			resp.setErrorNo(999999);
			resp.setErrorInfo("新增定时任务失败，请联系相关技术人员！");
			logger.error(resp.getErrorInfo(), e);
		}

		return resp;
	}

}

（3）logic逻辑层

package com.test.logic.job;

import java.util.ArrayList;
import java.util.List;
import java.util.Set;

import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.collections.Predicate;
import org.quartz.CronScheduleBuilder;
import org.quartz.CronTrigger;
import org.quartz.JobBuilder;
import org.quartz.JobDataMap;
import org.quartz.JobDetail;
import org.quartz.JobKey;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.Trigger;
import org.quartz.Trigger.TriggerState;
import org.quartz.TriggerBuilder;
import org.quartz.TriggerKey;
import org.quartz.impl.matchers.GroupMatcher;
import org.quartz.utils.Key;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;
import org.springframework.stereotype.Component;

import com.chinabond.core.exception.BusinessException;
import com.test.pojo.job.QuartzJob;
import com.test.pojo.job.UseJob;
import com.test.pojo.job.UseJobDto;
import com.test.utils.StringUtils;

@Component
public class UseJobLogic {

	private static final String GROUP_NAME_DEFAULT = Key.DEFAULT_GROUP;
	@Autowired(required = false)
	private SchedulerFactoryBean schedulerFactory;

	/**
	 * 获取线程调度器
	 * 
	 * @return
	 */
	private Scheduler getScheduler() {

		Scheduler scheduler = schedulerFactory.getScheduler();
		if (scheduler == null) {
			throw new BusinessException("999999", "定时任务调度器为空，请确认是否开启定时任务功能！");
		}
		return scheduler;
	}

	public List<UseJob> queryJobs(UseJob useJob) throws SchedulerException {
		List<UseJob> ls = new ArrayList<UseJob>();

		Set<TriggerKey> triggerKeys = getScheduler()
				.getTriggerKeys(GroupMatcher.triggerGroupEquals(GROUP_NAME_DEFAULT));
		for (TriggerKey triggerKey : triggerKeys) {
			Trigger trigger = getScheduler().getTrigger(triggerKey);
			TriggerState triggerState = getScheduler().getTriggerState(triggerKey);

			UseJobDto useJobDto = (UseJobDto) getScheduler().getJobDetail(trigger.getJobKey()).getJobDataMap()
					.get("useJobDto");
			if (useJobDto == null) {
				// 只处理新增的
				continue;
			}
			useJobDto.setJobState(triggerState.toString());
			useJobDto.setNextFireTime(trigger.getNextFireTime());
			ls.add(useJobDto);

		}

		// 条件查询
		CollectionUtils.filter(ls, new Predicate() {
			@Override
			public boolean evaluate(Object object) {
				if (object == null || !(object instanceof UseJob)) {
					return false;
				}
				UseJob temp = (UseJob) object;

				if (StringUtils.isNotBlank(useJob.getJobName()) && !temp.getJobName().contains(useJob.getJobName())) {
					return false;
				}

				if (StringUtils.isNotBlank(useJob.getJobState())
						&& !StringUtils.equals(useJob.getJobState(), temp.getJobState())) {
					return false;
				}

				return true;
			}
		});
		return ls;
	}

	/**
	 * 判断任务是否存在
	 * 
	 * @param job
	 * @return
	 * @throws SchedulerException
	 */
	public boolean isExistJob(UseJobDto job) throws SchedulerException {
		TriggerKey triggerKey = TriggerKey.triggerKey(job.getTriggerKey(), GROUP_NAME_DEFAULT);
		CronTrigger trigger = (CronTrigger) getScheduler().getTrigger(triggerKey);
		return trigger != null;
	}

	/**
	 * <pre>
	 * addJob(这里用一句话描述这个方法的作用)   
	 * 创建人：任智伟
	 * 创建时间：2020年9月18日 上午9:51:36    
	 * 修改人：任智伟      
	 * 修改时间：2020年9月18日 上午9:51:36    
	 * 修改备注： 
	 * &#64;param job
	 * &#64;throws SchedulerException
	 * </pre>
	 */
	public void addJob(UseJobDto job) throws SchedulerException {
		TriggerKey triggerKey = TriggerKey.triggerKey(job.getTriggerKey(), GROUP_NAME_DEFAULT);
		CronTrigger trigger = (CronTrigger) getScheduler().getTrigger(triggerKey);
		if (trigger == null) {
			/** Trigger不存在，则新建 */

			JobDataMap jobDataMap = new JobDataMap();
			job.setJobState(TriggerState.NORMAL.toString());
			jobDataMap.put("useJobDto", job);

			// 新建任务
			JobKey jobKey = new JobKey(job.getJobDetailKey(), GROUP_NAME_DEFAULT);
			JobDetail jobDetail = JobBuilder.newJob(QuartzJob.class).setJobData(jobDataMap).withIdentity(jobKey)
					.requestRecovery(true).storeDurably(true).build();

			// 表达式调度构建器
			CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(job.getExpression());

			// 构建触发器
			trigger = TriggerBuilder.newTrigger().withIdentity(triggerKey).withSchedule(scheduleBuilder).build();

			// 装配任务
			System.out.println("暂停ing-------------");
			getScheduler().scheduleJob(jobDetail, trigger);
			getScheduler().pauseTrigger(triggerKey);

		}

	}

	/**
	 * <pre>
	 * isPausedJob(判断任务状态是否已执行)   
	 * 创建人：任智伟
	 * 创建时间：2020年9月24日 上午10:31:01    
	 * 修改人：任智伟      
	 * 修改时间：2020年9月24日 上午10:31:01    
	 * 修改备注： 
	 * &#64;param job  定时任务
	 * &#64;return 暂停 ：true ，其他 ：false
	 * </pre>
	 * 
	 * @throws SchedulerException
	 */
	public boolean isPausedJob(UseJobDto job) throws SchedulerException {
		TriggerState triggerState = getScheduler().getTriggerState(TriggerKey.triggerKey(job.getTriggerKey()));
		return triggerState.toString().equals(TriggerState.PAUSED.toString());
	}

	/**
	 * <pre>
	 * startUseJob(启动定时任务)   
	 * 创建人：任智伟
	 * 创建时间：2020年9月24日 上午10:36:42    
	 * 修改人：任智伟      
	 * 修改时间：2020年9月24日 上午10:36:42    
	 * 修改备注： 
	 * &#64;param job 定时任务
	 * </pre>
	 * 
	 * @throws SchedulerException
	 */
	public void startUseJob(UseJobDto job) throws SchedulerException {
		getScheduler().resumeTrigger(TriggerKey.triggerKey(job.getTriggerKey()));
		getScheduler().resumeJob(JobKey.jobKey(job.getJobDetailKey()));
	}

	/**
	 * <pre>
	 * stopUseJob(停止定时任务)   
	 * 创建人：任智伟
	 * 创建时间：2020年9月24日 上午11:10:47    
	 * 修改人：任智伟      
	 * 修改时间：2020年9月24日 上午11:10:47    
	 * 修改备注： 
	 * &#64;param job
	 * </pre>
	 * 
	 * @throws SchedulerException
	 */
	public void stopUseJob(UseJobDto job) throws SchedulerException {

		getScheduler().pauseJob(JobKey.jobKey(job.getJobDetailKey()));
		getScheduler().pauseTrigger(TriggerKey.triggerKey(job.getTriggerKey()));

	}

	/**
	 * <pre>
	 * deleteJob(删除定时任务)   
	 * 创建人：任智伟
	 * 创建时间：2020年9月24日 下午4:54:57    
	 * 修改人：任智伟      
	 * 修改时间：2020年9月24日 下午4:54:57    
	 * 修改备注： 
	 * &#64;param job
	 * &#64;throws SchedulerException
	 * </pre>
	 */
	public void deleteJob(UseJobDto job) throws SchedulerException {
		if (getScheduler().checkExists(JobKey.jobKey(job.getJobDetailKey()))) {
			getScheduler().deleteJob(JobKey.jobKey(job.getJobDetailKey()));
		}

	}

	/**
	 * <pre>
	 * getUseJodInfo(修改回显查询数据)   
	 * 创建人：任智伟
	 * 创建时间：2020年9月29日 下午2:49:09    
	 * 修改人：任智伟      
	 * 修改时间：2020年9月29日 下午2:49:09    
	 * 修改备注： 
	 * &#64;param job
	 * &#64;return
	 * </pre>
	 * 
	 * @throws SchedulerException
	 */
	public UseJob getUseJodInfo(UseJobDto job) throws SchedulerException {
		TriggerKey triggerKey = TriggerKey.triggerKey(job.getTriggerKey());
		Trigger trigger = getScheduler().getTrigger(triggerKey);
		TriggerState triggerState = getScheduler().getTriggerState(triggerKey);

		UseJobDto jobDto = (UseJobDto) getScheduler().getJobDetail(JobKey.jobKey(job.getJobDetailKey())).getJobDataMap()
				.get("useJobDto");
		jobDto.setJobState(triggerState.toString());
		jobDto.setNextFireTime(trigger.getNextFireTime());
		return jobDto;
	}

	/**
	 * <pre>
	 * updateJob(修改定时任务)   
	 * 创建人：任智伟
	 * 创建时间：2020年10月12日 上午9:44:29    
	 * 修改人：任智伟      
	 * 修改时间：2020年10月12日 上午9:44:29    
	 * 修改备注： 
	 * &#64;param job
	 * </pre>
	 * 
	 * @throws SchedulerException
	 */
	public void updateJob(UseJobDto job) throws SchedulerException {
		deleteJob(job);
		addJob(job);
	}

}
三、完成后效果

在这里插入图片描述
在这里插入图片描述
关联时间表达式的js代码逻辑较为复杂，这里就不展示了，有需要的小伙伴可以私我

任智伟15034149817
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
spring动态配置定时任务
05-01
完整的javaspring定时任务的实现，通过配置数据库可以实现定时任务的修改，不必频繁的修改配置文件，大家可以自行在上面实现更多的定时任务管理。数据库表结构已经上传
动态配置定时任务
weixin_30363981的博客
05-28 173
在我们开发中 我们常用定时任务 每次对任务的 修改 或者启停 在传统的方式里 我们需要修改他和spring的 集成后的 xml 这样 导致很麻烦 或者 我们在动态的 添加一个定时任务 每次也是比较麻烦 更具项目的需要 我们最后把 配置的事情 交给数据库来办 从而每次我们只要维护数据库就好 让我们的工程在 初始化的时候 保证我们定时任务 能够加载到spring既可 这是我们初步的 思...
spring实现定时任务的动态可配置、可删除、可启用停用功能
最新发布
saonian0929的博客
06-21 513
springBoot在添加依赖的情况下实现定时任务的动态可配置、可删除、可启用停用功能
springboot动态配置定时任务(schedule)
06-13
springboot动态配置定时任务(schedule),可不重启项目实现开关重启任务,改变任务定时规则
动态定时任务
菜鸟程序员的成长之路
12-01 1792
SpringBoot动态定时任务
web页面可配置话的动态生成spring定时任务，持续到化数据库
07-26
基于spring的一个web项目集成页面可动态配置到数据的定时任务。没有给出完整的代码，但是前台的form和list页面，后台的三层和工具类等代码都给出了，我觉得做过web前后台的应该是很容易看懂的。
Quartz实现JAVA定时任务的动态配置的方法
08-27
动态配置定时任务是指能够在不停止应用程序的情况下，动态添加、删除、修改定时任务的触发时间和执行方式的能力。这在实际项目中非常有用，例如在某些情况下需要临时添加或删除某些定时任务，而不需要停止应用程序。...
furion内置的定时任务使用学习，动态添加定时任务代码
10-24
`Program.cs` 是ASP.NET Core应用的入口点，通常在这里启用Furion框架并配置定时任务服务。通过调用`UseFurion()`扩展方法，我们可以启动Furion并使用其特性，而`AddJobs()`方法则用于注册定时任务服务。此外，还...
定时任务quartz实现分组串行并行动态配置
05-06
在实际应用中，我们可能需要根据业务需求动态地配置定时任务的执行方式，例如，某些任务可能需要串行执行，而其他任务则可以并行处理。本篇文章将深入探讨如何利用Quartz实现定时任务的分组、串行和并行动态配置。 ...
Django+Celery实现动态配置定时任务的方法示例
09-16
在本文中，我们将深入探讨如何使用Django与Celery框架实现动态配置定时任务。Django是一个流行的Python web框架，而Celery则是一个分布式任务队列，适用于处理异步任务和定时任务。结合两者，我们可以创建一个强大的...
Spring普通定时任务和动态设置定时任务
08-25
Spring普通定时任务和动态设置定时任务.本资源仅供Spring有关的框架学习使用
spring整合java quartz实现动态定时任务的前台网页配置与管理
12-29
在实际项目应用中经常会用到定时任务，可以通过quartz和spring的简单配置即可完成，但如果要改变任务的执行时间、频率，废弃任务等就需要改变配置甚至代码需要重启服务器，这里介绍一下如何通过quartz与spring的组合实现动态的改变定时任务的状态的一个实现。 该jar包提供java项目源码，数据库文件以及完整的jar包。可发布运行。 如果要多问题，私信我，我会帮助解决。
SpringBoot基础教程3-1-1 简单定时任务方法介绍
weixin_34150830的博客
09-29 57
2019独角兽企业重金招聘Python工程师标准>>> ...
Spring+Quartz实现定时任务自动化动态配置
叶落自飘零的博客
05-29 4640
背景： 一个系统定时任务是不可避免的，现有的spring Task也可以很好的解决定时任务的配置；但其中的缺点也是很显而易见的，即不能够做到可插拔式，每次改动都需要重启服务；所以在这里想做一套可自动化配置的定时任务处理机制： 环境： spring：3.2.0.RELEASE quartz：2.2.1 原理： 本套机制还是使用Quartz的核心原理进行封装配置。 Quartz的优点有：...
Quartz定时任务
StormEnum
01-27 7041
一、Quartz的核心概念 1.任务job job就是想要实现的任务类，每一个job必须实现job接口，且实现接口中的 excute（）方法。 2.触发器Trigger Trigger为你执行任务的触发器，可以设置特定时间执行该任务 Trigger主要包含SimpleTrigger和CronTrigger两种 3.调度器Scheduler Scheduler为任务的调度器，它会将任务job及触发器...
quartz定时任务
qq_39529324的博客
06-29 241
&lt;?xml version="1.0" encoding="UTF-8"?&gt;&lt;beans xmlns="http://www.springframework.org/schema/beans"     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"    xmlns:context="http://www.spring
spring-quartz定时任务整合
hao114500043的专栏
10-24 426
1.增加quartz的jar包 quartz-2.2.1.jar quartz-jobs-2.2.1.jar 2.web.xml中增加使用quartz的配置文件 contextConfigLocation classpath:spring.xml,classpath:spring-task.xml 3.spring-task.XML文件 <beans xml
queryZ定时任务
weixin_41254254的博客
06-28 1580
什么是定时任务 有一个函数
在Maven项目中使用StringUtils报错java.lang.NoClassDefFoundError: org/apache/commons/lang3/StringUtils
PCQOffer的博客
05-12 1626
错误在与没有这个包，但是我在pom.xml文件中已经导入依赖。运行时依然报错。 HTTP Status 500 – Internal Server Error Type Exception Report Message Servlet execution threw an exception Description The server encountered an unexpected condition that prevented it from fulfilling the request.
springboot @scheduled定时任务动态配置
11-10
3.创建一个定时任务类，使用@Scheduled注解来标记定时任务方法，并在方法上添加参数来动态配置定时任务的执行时间。例如： ```java @Component public class MyTask { @Scheduled(cron = "${mytask.cron}") ...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值