Quartz动态添加，修改，删除任务(暂停，任务状态，恢复，最近触发时间)

最新推荐文章于 2023-02-07 15:19:34 发布
最新推荐文章于 2023-02-07 15:19:34 发布
阅读量1.2w 收藏 46
点赞数 9
文章标签： quartz 任务的crud 动态添加修改删除 任务状态 cron最近触发时间
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/loveLifeLoveCoding/article/details/80449077
版权

本案例采用quartz-2.2.3.jar

入门案例，执行比较简单的任务

QuartzManager.java  (任务的管理)

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

import org.quartz.CronScheduleBuilder;
import org.quartz.CronTrigger;
import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.JobKey;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SchedulerFactory;
import org.quartz.Trigger;
import org.quartz.Trigger.TriggerState;
import org.quartz.TriggerBuilder;
import org.quartz.TriggerKey;
import org.quartz.TriggerUtils;
import org.quartz.impl.StdSchedulerFactory;
import org.quartz.impl.triggers.CronTriggerImpl;

public class QuartzManager {

	private static SchedulerFactory gSchedulerFactory = new StdSchedulerFactory();
	private static String JOB_GROUP_NAME = "MY_JOBGROUP_NAME";
	private static String TRIGGER_GROUP_NAME = "MY_TRIGGERGROUP_NAME";

	/**
	 * @Description: 添加一个定时任务，使用默认的任务组名，触发器名，触发器组名
	 * @param jobName
	 *            任务名
	 * @param cls
	 *            任务
	 * @param time
	 *            时间设置，参考quartz说明文档
	 */
	@SuppressWarnings({ "rawtypes", "unchecked" })
	public static void addJob(String jobName, Class cls, String cron) {
		try {
			Scheduler sched = gSchedulerFactory.getScheduler();
			JobDetail job = JobBuilder.newJob(cls).withIdentity(jobName, JOB_GROUP_NAME).build();
			// 表达式调度构建器
			CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(cron);
			// 按新的cronExpression表达式构建一个新的trigger
			Trigger trigger = TriggerBuilder.newTrigger().withIdentity(jobName, TRIGGER_GROUP_NAME)
					.withSchedule(scheduleBuilder).build();

			// 交给scheduler去调度
			sched.scheduleJob(job, trigger);

			// 启动
			if (!sched.isShutdown()) {
				sched.start();
				System.err.println("添加任务:"+jobName);
			}
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}

	/**
	 * @Description: 添加一个定时任务
	 * @param jobName
	 *            任务名
	 * @param jobGroupName
	 *            任务组名
	 * @param triggerName
	 *            触发器名
	 * @param triggerGroupName
	 *            触发器组名
	 * @param jobClass
	 *            任务
	 * @param time
	 *            时间设置，参考quartz说明文档
	 */
	@SuppressWarnings({ "rawtypes", "unchecked" })
	public static void addJob(String jobName, String jobGroupName, String triggerName, String triggerGroupName,
			Class jobClass, String cron) {
		try {
			Scheduler sched = gSchedulerFactory.getScheduler();
			JobDetail job = JobBuilder.newJob(jobClass).withIdentity(jobName, jobGroupName).build();
			// 表达式调度构建器
			CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(cron);
			// 按新的cronExpression表达式构建一个新的trigger
			Trigger trigger = TriggerBuilder.newTrigger().withIdentity(triggerName, triggerGroupName)
					.withSchedule(scheduleBuilder).build();
			sched.scheduleJob(job, trigger);
			// 启动
			if (!sched.isShutdown()) {
				sched.start();
			}
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}

	/**
	 * @Description: 修改一个任务的触发时间(使用默认的任务组名，触发器名，触发器组名)
	 * @param jobName
	 * @param time
	 */
	public static void modifyJobTime(String jobName, String cron) {
		TriggerKey triggerKey = TriggerKey.triggerKey(jobName, TRIGGER_GROUP_NAME);

		try {
			Scheduler sched = gSchedulerFactory.getScheduler();
			CronTrigger trigger = (CronTrigger) sched.getTrigger(triggerKey);
			if (trigger == null) {
				return;
			}
			String oldTime = trigger.getCronExpression();
			if (!oldTime.equalsIgnoreCase(cron)) {
				CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(cron);
				// 按新的cronExpression表达式重新构建trigger
				trigger = trigger.getTriggerBuilder().withIdentity(triggerKey).withSchedule(scheduleBuilder).build();
				// 按新的trigger重新设置job执行
				sched.rescheduleJob(triggerKey, trigger);
			}
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}

	
	/**
	 * @Description:修改任务，（可以修改任务名，任务类，触发时间）
	 * 		原理：移除原来的任务，添加新的任务	
	 * @param oldJobName ：原任务名
	 * @param jobName
	 * @param jobclass
	 * @param cron
	 * @date 2018年5月23日 上午9:13:10    
	 */
	@SuppressWarnings({ "rawtypes", "unchecked" })
	public static void modifyJob(String oldJobName, String jobName, Class jobclass, String cron) {
		/*
		 * removeJob(oldJobName); 
		 * addJob(jobName, jobclass, cron);
		 * System.err.println("修改任务"+oldJobName);
		 */
		TriggerKey triggerKey = TriggerKey.triggerKey(oldJobName, TRIGGER_GROUP_NAME);
		JobKey jobKey = JobKey.jobKey(oldJobName, JOB_GROUP_NAME);
		try {
			Scheduler sched = gSchedulerFactory.getScheduler();
			Trigger trigger = (Trigger) sched.getTrigger(triggerKey);
			if (trigger == null) {
				return;
			}
			sched.pauseTrigger(triggerKey);// 停止触发器
			sched.unscheduleJob(triggerKey);// 移除触发器
			sched.deleteJob(jobKey);// 删除任务
			System.err.println("移除任务:" + oldJobName);

			JobDetail job = JobBuilder.newJob(jobclass).withIdentity(jobName, JOB_GROUP_NAME).build();
			// 表达式调度构建器
			CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(cron);
			// 按新的cronExpression表达式构建一个新的trigger
			Trigger newTrigger = TriggerBuilder.newTrigger().withIdentity(jobName, TRIGGER_GROUP_NAME)
					.withSchedule(scheduleBuilder).build();

			// 交给scheduler去调度
			sched.scheduleJob(job, newTrigger);

			// 启动
			if (!sched.isShutdown()) {
				sched.start();
				System.err.println("添加新任务:" + jobName);
			}
			System.err.println("修改任务【" + oldJobName + "】为:" + jobName);
		} catch (Exception e) {
			throw new RuntimeException(e);
		}

	}
	
	
	/**
	 * @Description: 修改一个任务的触发时间
	 * @param triggerName
	 * @param triggerGroupName
	 * @param time
	 */
	public static void modifyJobTime(String triggerName, String triggerGroupName, String cron) {
		TriggerKey triggerKey = TriggerKey.triggerKey(triggerName, triggerGroupName);
		try {
			Scheduler sched = gSchedulerFactory.getScheduler();
			CronTrigger trigger = (CronTrigger) sched.getTrigger(triggerKey);
			if (trigger == null) {
				return;
			}
			String oldTime = trigger.getCronExpression();
			if (!oldTime.equalsIgnoreCase(cron)) {
				// trigger已存在，则更新相应的定时设置
				CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(cron);
				// 按新的cronExpression表达式重新构建trigger
				trigger = trigger.getTriggerBuilder().withIdentity(triggerKey).withSchedule(scheduleBuilder).build();
				// 按新的trigger重新设置job执行
				sched.resumeTrigger(triggerKey);
			}
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}

	/**
	 * @Description 移除一个任务(使用默认的任务组名，触发器名，触发器组名)
	 * @param jobName
	 */
	public static void removeJob(String jobName) {
		TriggerKey triggerKey = TriggerKey.triggerKey(jobName, TRIGGER_GROUP_NAME);
		JobKey jobKey = JobKey.jobKey(jobName, JOB_GROUP_NAME);
		try {
			Scheduler sched = gSchedulerFactory.getScheduler();
			Trigger trigger = (Trigger) sched.getTrigger(triggerKey);
			if (trigger == null) {
				return;
			}
			sched.pauseTrigger(triggerKey);// 停止触发器
			sched.unscheduleJob(triggerKey);// 移除触发器
			sched.deleteJob(jobKey);// 删除任务
			System.err.println("移除任务:"+jobName);
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}

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

	/**
	 * @Description:暂停一个任务(使用默认组名)
	 * @param jobName
	 */
	public static void pauseJob(String jobName) {
		JobKey jobKey = JobKey.jobKey(jobName, JOB_GROUP_NAME);
		try {
			Scheduler sched = gSchedulerFactory.getScheduler();
			sched.pauseJob(jobKey);
		} catch (SchedulerException e) {
			e.printStackTrace();
		}
	}

	/**
	 * @Description:暂停一个任务
	 * @param jobName
	 * @param jobGroupName
	 */
	public static void pauseJob(String jobName, String jobGroupName) {
		JobKey jobKey = JobKey.jobKey(jobName, jobGroupName);
		try {
			Scheduler sched = gSchedulerFactory.getScheduler();
			sched.pauseJob(jobKey);
		} catch (SchedulerException e) {
			e.printStackTrace();
		}
	}

	/**
	 * @Description:恢复一个任务(使用默认组名)
	 * @param jobName
	 */
	public static void resumeJob(String jobName) {
		JobKey jobKey = JobKey.jobKey(jobName, JOB_GROUP_NAME);
		try {
			Scheduler sched = gSchedulerFactory.getScheduler();
			sched.resumeJob(jobKey);
		} catch (SchedulerException e) {
			e.printStackTrace();
		}
	}

	/**
	 * @Description:恢复一个任务
	 * @param jobName
	 * @param jobGroupName
	 * @date 2018年5月17日 上午9:56:09
	 */
	public static void resumeJob(String jobName, String jobGroupName) {
		JobKey jobKey = JobKey.jobKey(jobName, jobGroupName);
		try {
			Scheduler sched = gSchedulerFactory.getScheduler();
			sched.resumeJob(jobKey);
		} catch (SchedulerException e) {
			e.printStackTrace();
		}
	}

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

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

	/**
	 * @Description: 立即运行任务，这里的立即运行，只会运行一次，方便测试时用。
	 * @param jobName
	 * @param jobGroupName
	 * @date 2018年5月17日 上午10:03:26
	 */
	public static void triggerJob(String jobName) {
		JobKey jobKey = JobKey.jobKey(jobName, JOB_GROUP_NAME);
		try {
			Scheduler sched = gSchedulerFactory.getScheduler();
			sched.triggerJob(jobKey);
		} catch (SchedulerException e) {
			e.printStackTrace();
		}
	}

	/**
	 * @Description: 立即运行任务，这里的立即运行，只会运行一次，方便测试时用。
	 * @param jobName
	 * @param jobGroupName
	 * @date 2018年5月17日 上午10:03:26
	 */
	public static void triggerJob(String jobName, String jobGroupName) {
		JobKey jobKey = JobKey.jobKey(jobName, jobGroupName);
		try {
			Scheduler sched = gSchedulerFactory.getScheduler();
			sched.triggerJob(jobKey);
		} catch (SchedulerException e) {
			e.printStackTrace();
		}
	}
	
	/**
	 * @Description: 获取任务状态
	 * 		NONE: 不存在
	 * 		NORMAL: 正常
	 * 		PAUSED: 暂停
	 * 		COMPLETE:完成
	 * 		ERROR : 错误
	 * 		BLOCKED : 阻塞
	 * @param jobName 触发器名
	 * @date 2018年5月21日 下午2:13:45    
	 */
	public static String getTriggerState(String jobName){
		TriggerKey triggerKey = TriggerKey.triggerKey(jobName, TRIGGER_GROUP_NAME);
		String name = null;
		try {
			Scheduler sched = gSchedulerFactory.getScheduler();
			TriggerState triggerState = sched.getTriggerState(triggerKey);
			name = triggerState.name();
		} catch (SchedulerException e) {
			e.printStackTrace();
		}
		return name;
	}

	/**
	 * @Description:获取最近8次执行时间
	 * @param cron
	 * @date 2018年5月24日 下午5:13:03    
	 */
	public static List<String> getRecentTriggerTime(String cron) {
		List<String> list = new ArrayList<String>();
		try {
			CronTriggerImpl cronTriggerImpl = new CronTriggerImpl();
			cronTriggerImpl.setCronExpression(cron);
			// 这个是重点，一行代码搞定
			List<Date> dates = TriggerUtils.computeFireTimes(cronTriggerImpl, null, 8);
			SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
			for (Date date : dates) {
				list.add(dateFormat.format(date));
			}
			
		} catch (ParseException e) {
			e.printStackTrace();
		}
		return list;
	}
	
}

MyJob.java  执行的任务


import java.text.SimpleDateFormat;
import java.util.Calendar;

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;

/**
 * @Description:
 * @date 2018年5月16日
 */
public class MyJob implements Job {

    @Override  
    public void execute(JobExecutionContext context) throws JobExecutionException {  
          
    	System.err.println("任务运行开始-------- start --------");   
        try {  
        	String jobName = context.getJobDetail().getKey().getName();
        	String jobGroup = context.getJobDetail().getKey().getGroup();
        	String triggerName = context.getTrigger().getKey().getName();
        	String triggerGroup = context.getTrigger().getKey().getGroup();
        	
        	SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
        	System.err.println("触发器Key:" + triggerName + ".." + triggerGroup + " 正在执行...");
        	System.err.println("任务Key:" + jobName + ".." + jobGroup + " 正在执行，执行时间: "
        			+ dateFormat.format(Calendar.getInstance().getTime()));
        	
        }catch (Exception e) {  
        	System.err.println("捕获异常==="+e);  
        }  
        System.err.println("任务运行结束-------- end --------");   
    }  
    
}

测试类 LoadTask.java


public class LoadTask {  
  
	public static void main(String[] args) {
		System.err.println("【系统启动】");  
		String corn = "0/5 * * * * ?";
		//QuartzManager.addJob("job1", "jobGooup", "trigger1", "triggerGroup", MyJob.class, corn);
		QuartzManager.addJob("job1",  MyJob.class, corn);
		System.err.println("添加任务一"); 
		QuartzManager.getTriggerState("jobs");
		
		//睡眠一分钟
		try {
			Thread.sleep(60L * 1000L);
		} catch (InterruptedException e) {
			e.printStackTrace();
		} 
		
		
		QuartzManager.modifyJobTime("job1", "0/3 * * * * ?");
		System.out.println("修改触发时间");
		
		try {
			Thread.sleep(15L * 1000L);
		} catch (InterruptedException e) {
			e.printStackTrace();
		} 
		
		QuartzManager.removeJob("job1");
		//QuartzManager.removeJob("job1", "jobGooup", "trigger1", "triggerGroup");
		System.out.println("删除任务");
		
		try {
			Thread.sleep(5L * 1000L);
		} catch (InterruptedException e) {
			e.printStackTrace();
		} 
		
		 System.out.println("【添加定时任务】");  
		 QuartzManager.addJob("job1",  MyJob.class, corn);
		//QuartzManager.shutdownJobs();
		//System.out.println("停止所有任务");
		try {
			Thread.sleep(5L * 1000L);
		} catch (InterruptedException e) {
			e.printStackTrace();
		} 
		
		 System.out.println("【暂停定时任务】"); 
		QuartzManager.pauseJob("job1");
		 System.out.println("【立即运行一次】"); 
		QuartzManager.triggerJob("job1");
		try {
			Thread.sleep(5L * 1000L);
		} catch (InterruptedException e) {
			e.printStackTrace();
		} 
		
		 System.out.println("【恢复定时任务】"); 
		QuartzManager.resumeJob("job1");
		try {
			Thread.sleep(5L * 1000L);
		} catch (InterruptedException e) {
			e.printStackTrace();
		} 
		
		QuartzManager.shutdownJobs();
	}
}
loveLifeLoveCoding
关注
  • 9
    点赞
  • 踩
  • 46
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
Spring Quartz 动态暂停、恢复、修改定时任务
01-06
Spring Quartz 动态暂停、恢复、修改定时任务的一个demo，使用maven构建，框架采用spring springmvc jpa，数据库mysql，含数据库脚本，运行可用，页面访问地址http://localhost:8080/quartz_demo/quartz/list
任务调度开源框架Quartz动态添加、修改和删除定时任务
07-30
任务调度开源框架Quartz动态添加、修改和删除定时任务
定时任务quartz实现分组串行并行动态配置
05-06
定时任务quartz实现分组串行并行动态配置
quartz动态添加、修改和删除定时任务
01-06
附件中实现了对quartz的动态添加、修改和删除定时任务，方便通过页面动态控制执行定时任务。
【C#】异步编程自定义任务调度器TaskScheduler介绍
m0_38045338的博客
10-22 5218
自定义任务调试器 [C#]多线程基础 [C#]ThreadPool与Task 文章目录自定义任务调试器一、TaskScheduler是什么？二、具体实现1.程序文件结构2.前端代码3. 自定义调度器代码4.调试结果总结 一、TaskScheduler是什么？ 有时需要创建一组共享相同配置的Task对象，为避免机械地将相同的参数传给每个Task构造器，可创建一个任务工厂来封装通用的配置。System.Threading.Tasks命名空间定义了一个TaskFactory类型和一个TaskFactory类型。
quartz使用（二）任务的删除，停止，暂停，启动
毅香雪海的博客
02-27 8376
在上一篇文章中，介绍了quartz简单的使用方法，没有看过的可以查看https://editor.csdn.net/md/?articleId=102677404 这一篇介绍关于任务的启动停止这些操作，废话不多说。 任务启动停止 启动任务 void start() throws SchedulerException; // 启动任务 停止任务 void shutdown() t...
QuartzManager定时器管理
qq_39543482的博客
10-08 743
@Component @Scope("singleton") @Slf4j public class QuartzManager implements ApplicationListener<ApplicationPreparedEvent> { private static SchedulerFactory schedulerFactory = new StdSchedul...
Quartz定时任务管理（动态添加、停止、恢复、删除定时任务）
古甲哈醒的专栏
02-26 9685
通过Quatrz定时任务管理，动态添加修改定时任务，比如添加新的定时任务、修改任务执行时间、暂停定时任务、删除定时任务等，并且监控定时任务状态
asp.net mvc 项目使用Quartz.net添加定时任务
whuzjn的专栏
03-18 3886
文章目录1、安装Quartz.net2、创建定时任务工具类“QuartzUtil”3、创建任务运行类4、在程序启动类里启动定时任务引擎5、调用定时任务6、DEMO实例下载 1、安装Quartz.net （1）打开“程序包管理器控制台（PM）” （2）执行命令 PM> Install-Package Quartz 2、创建定时任务工具类“QuartzUtil” using System...
ASP.NET quartz 定时任务
weixin_30772105的博客
10-25 62
1.下载 2.使用例子 Demo 概述：Quartz 是开源的定时任务工具类，默认每隔10秒执行一次任务，相当于C#的Timer，不断的循环执行（Start 方法），也可以随时停止（ShutDown方法）。 一 下载 下载地址：quartz 二 使用例子 Demo 1）引入程序集，必须引入三个，不然报错 2）IScheduler 和 IJob publ...
java Quartz动态添加、删除job
qq_27106141的博客
02-07 1466
java Quartz动态添加、删除job
Quartz的故障恢复
iteye_19215的博客
11-19 1191
     在默认的情况下，Quartz中所提交的任务都是独立的运行在内存中的线程，这意味着一旦机器出现故障或任何原因这个线程被干掉，那么提交的任务就无法继续也无法恢复。如果我们想要在系统出现故障的情况下恢复Quartz中的任务，就要把当前任务状态持久化，然后在系统恢复之后恢复任务的执行，这就是基本的解决思路。Quartz在这方面也提供了支持。        首先，持久化的问题。要进行恢复就要...
【二】Quartz定时任务持久化到数据库中
mengyb个人文档记录
12-30 2031
Quartz持久化数据库
SpringBoot Quartz 动态定时任务
qq_22074337的博客
06-08 1865
SpringBoot Quartz 动态定时任务
Quartz入门——定时任务动态添加修改及持久化与自动恢复
Robod的博客
08-16 5148
这篇文章就带小伙伴们了解一下Quartz的基本使用。包括基本概念以及如何动态地的定时任务进行CRUD，并且如何实现定时任务的持久化以及任务恢复
Spring 3整合Quartz 2实现定时任务三：动态暂停 恢复 修改和删除任务
black_fuck的专栏
05-14 1106
前面我们已经完成了spring 3和quartz 2的整合以及动态添加定时任务，我们接着来完善它，使之能支持更多的操作，例如暂停、恢复、修改等。 在动态添加定时任务中其实已经涉及到了其中的一些代码，这里我们再来细化的理一理。先来看一下我们初步要实现的目标效果图，这里我们只在内存中操作，并没有把quartz的任何信息保存到数据库，即使用的是RAMJobStore，当然如果你有需要，可以实现成J
Quartz 分布式定时任务动态添加&删除定时任务
K_Men的博客
01-14 6668
首先对于Quartz的原理和使用这里不再做赘述和讲解，相信大家可以自信查阅文档进行使用。先说一下个人的这个使用背景：项目中需要引入定时任务，框架是springcloud分布式系统然后调研之后决定引入Quartz,他需要基于数据库特定的表来存储定时任务相关的数据等，普通的定时任务比如：日终定时批量进行某些数据的处理扫描等也可以使用，不过那个需要项目启动后就将任务进行添加并启动。对于特定的动态生成的任务：比如前端进行提交某些数据调用服务端接口时需要根据业务需求生成一个未来的时间进行执行的任务逻辑...
springboot整合quartz实现动态添加、修改、删除、停止job，以及优化quartz工具类，支持自动停止逻辑
u013611978的博客
09-10 2556
原文链接：http://pengfeiguo.com:8085/articles 什么是Quartz？ 一个定时任务调度框架，简单易用，功能强大可以使实现定时任务的。 优点： 支持集群下定时任务处理 支持任务并发阻塞（上一个任务完成后，才能继续下一个任务） 支持通过API对任务的操作，例如新增任务、修改、启动、暂停、停止（可以在代码中进行调用，而无需修改配置文件再次部署） 支持的数据库种类被较多 目标 在Spring Boot中集成Quartz 使用MySql数据库（程序自动导入，无需人工
c# 添加 修改 删除 quartz任务
最新发布
09-29
c是英语字母表的第三个字母，也是音素/ku:/（/k/和/u:/两个音素组合）的音标表示。 c在常见词汇中有许多用途和意思。例如，在数学中，c常代表常数。在化学中，c代表摩尔浓度。在计算机科学中，c代表语言或编程中的C语言。在音乐中，C代表音阶中的音符。此外，C还有许多其他用途，例如表示摄氏度（温度单位），代表公司（例如Coca-Cola），还可以代表一个未知量。 在罗马数字中，c代表100。在一些罗马数字的组合中，c还可以代表其他数字，如400（CD）和900（CM）。 在国际象棋中，c代表象（chess）。在航海中，c代表海里（nautical mile）的单位。 "C"也可以代表一些成语或简写词，例如"C++"是一种计算机编程语言，"c'est la vie"是法语，意为“这就是生活”，常用于接受或表示对某种令人失望的情况的无奈。 总之，c是一个多功能字母，在不同的语境中代表不同的概念和意义。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值