定时任务 流程

最新推荐文章于 2024-03-25 20:17:34 发布
最新推荐文章于 2024-03-25 20:17:34 发布
阅读量510 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/AdrianSimon/article/details/93619804
版权

定时任务列表

		<br> <br>
		<button class="btn btn-primary pull-left" type="button" id="retu">返回</button>
		<br> <br> <br>
		<form class="yzForm" id="editFrom">
			<div id="toolbar" class="form-group" style="height: 50px; display:none;">
				<strong>id：</strong><input class="form-control" type="text" 
					id=quartzId name="quartzId" style="margin: 5px;"></input>
			</div>
			<div id="toolbar" class="form-group" style="height: 50px;">
				<strong>任务名：</strong><input class="form-control" type="text"
					id=name name="name" style="margin: 5px;"></input>
			</div>
			<div id="toolbar" class="form-group" style="height: 50px;">
				<strong>任务组：</strong><input class="form-control" type="text"
					id="group" name="group" style="margin: 5px;"></input>
			</div>
			<div id="toolbar" class="form-group" style="height: 50px;">
				<strong>定时规则：<span id="sidebar"><a href="http://cron.qqe2.com/" target='_BLANK'>获取Cron 表达式</a></span></strong><input class="form-control" type="text"
					id="cron" name="cron" style="margin: 5px;"></input>
			</div>
			<div id="toolbar" class="form-group" style="height: 50px;">
				<strong>任务类：</strong><input class="form-control" type="text"
					id="className" name="className" style="margin: 5px;"></input>
			</div>
		
		</form>
			<button id="save" type="button" class="btn btn-primary" >提交</button>
	</div>

var save = document.getElementById("save");
//提交
save.onclick = function() {
	
	var form = $('#editFrom').serialize();
	var id=	document.getElementById('quartzId').value;
	debugger
	//提交新建的form表单task
	if(id==""){
			 	$.ajax({
			 		url : "/manage/addtask",
					data :form,
					type : "post",
					datType : "json",
					success : function(result) {
						debugger
						if (result) {	alert("成功");$('.adddate').hide(); $('.canceldate').show();
						$("#tabled").bootstrapTable('refresh');
						} else {alert("失败");}
					}
				});
			 	} else {	//提交修改的form表单task
					$.ajax({
				 		url : "/manage/updatetask", // 目标地址
						data :form,
						type : "post",
						datType : "json",
						success : function(result) {
							if (result) {alert("成功");$('.adddate').hide(); $('.canceldate').show();
							$("#tabled").bootstrapTable('refresh');
							}else{
								alert("失败");
							}
						}
					});
				}
		}

// 加入Qulifier注解，通过名称注入bean
@Autowired

@Qualifier(“Scheduler”)
public Scheduler scheduler;
@Autowired
ScheduleJobService ScheduleJobServiceImpl;
//新建
@RequestMapping("/addtask")
@ResponseBody
public Map<String,Object> addJob( Task task) throws Exception {
Map<String,Object> resMap= new HashMap<String,Object>();
ScheduleJobServiceImpl.addJob(task);
resMap.put(“result”, true);
return resMap;
}

package com.sr.service.impl;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Random;

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.TriggerBuilder;
import org.quartz.TriggerKey;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.sr.entity.Task;
import com.sr.mapper.db1.TimingTaskDao;
import com.sr.service.BaseJob;
import com.sr.service.ScheduleJobService;

@Service
@Transactional
public class ScheduleJobServiceImpl implements ScheduleJobService{
// private static final int Task = 0;
@Autowired
@Qualifier(“Scheduler”)
private Scheduler scheduler;
@Autowired TimingTaskDao timingtaskdao;
// 自己选择所用的dao
/*
* @Autowired TaskService taskService;
*/

//新增一个任务
public String addJob(Task task) throws Exception {

	// 启动调度器
	scheduler.start();

	// 构建job信息 任务名，任务组，任务执行类
	JobDetail jobDetail = JobBuilder.newJob(getClass(task.getClassName()).getClass())
			.withIdentity(task.getName(), task.getGroup()).build();

	// 表达式调度构建器(即任务执行的时间)
	CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(task.getCron());

	// 按新的cronExpression表达式构建一个新的trigger
	CronTrigger trigger = TriggerBuilder.newTrigger().withIdentity(task.getName(), task.getGroup())
			.withSchedule(scheduleBuilder).build();

	try {
		Date date  = scheduler.scheduleJob(jobDetail, trigger);
		if(date!=null){
			timingtaskdao.addtask(task);
		}
		
		
	} catch (SchedulerException e) {
		e.printStackTrace();
	}
	return "success";
}

//批量暂停

@Override
public JobDetail jobPause(List<Task> task) throws Exception {
	
	for (int i = 0; i < task.size(); i++) {
	scheduler.pauseJob(JobKey.jobKey(task.get(i).getName(),task.get(i).getGroup()));
	timingtaskdao.pausetask(task.get(i).getName(),task.get(i).getGroup());
	}
	return null;
}
//恢复一个任务
@Override
public JobDetail startJob(String jobName, String jobGroupName) throws Exception {
	  JobKey jobKey = JobKey.jobKey(jobName, jobGroupName);
    scheduler.resumeJob(jobKey);
	timingtaskdao.statetask(jobName, jobGroupName);
	JobDetail detail = scheduler.getJobDetail(JobKey.jobKey(jobName, jobGroupName));
	
	return detail;
}
//批量删除
@Override
public void jobDetele(List<Task> task) throws SchedulerException {
	List<Integer> q1 = new ArrayList<>();
	List<JobKey> q2 = new ArrayList<>();
	for (int i = 0; i < task.size(); i++) {
		JobKey jobKey = JobKey.jobKey(task.get(i).getName(), task.get(i).getGroup());
   	q1.add(task.get(i).getQuartzId());
   	q2.add(jobKey);
	}
	scheduler.deleteJobs(q2);
   timingtaskdao.deletetask(q1);
}

public void jobreschedule(Task task) throws Exception {
	String  jobName=task.getName();
	String	jobGroupName=task.getGroup();
	String	cronExpression=task.getCron();
	try {
		TriggerKey triggerKey = TriggerKey.triggerKey(jobName, jobGroupName);
		// 表达式调度构建器
		CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(cronExpression);

		CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);

		// 按新的cronExpression表达式重新构建trigger
		trigger = trigger.getTriggerBuilder().withIdentity(triggerKey).withSchedule(scheduleBuilder).build();

		// 按新的trigger重新设置job执行
		Date date =scheduler.rescheduleJob(triggerKey, trigger);
		if(date!=null){
			timingtaskdao.updatetask(task);
		}
		
	} catch (SchedulerException e) {
		System.out.println("更新定时任务失败" + e);
	}
}
private static BaseJob getClass(String classname) throws Exception {
	Class<?> class1 = Class.forName(classname);
	return (BaseJob) class1.newInstance();
}


//新建
public int addtask(Task task) {
	int result=0;
	int min=1;
	int max=10000000;
	int intBounded = min + ((int) (new Random().nextFloat() * (max - min)));
	int quartzId = intBounded;
	task.setQuartzId(quartzId);	
	result=timingtaskdao.addtask(task);
   return result;
}

//根据id修改task字段

public int updatetask(Task task, Integer quartzId) {
	int result=0;
	task.setQuartzId(quartzId);	
	result=timingtaskdao.updatetask(task); 
	return result;
}

}

<?xml version="1.0" encoding="UTF-8"?> SELECT * FROM task SELECT * FROM task quartzId=#{_parameter} insert into Task ( name, className, `group`, cron, state ) values ( 
	<if test="name!=null  and name !='' ">
	#{name,jdbcType = VARCHAR },
	</if>
	<if test="className!=null  and className !='' ">
	#{className,jdbcType = VARCHAR },
	</if>
	<if test="group!=null and group !=''">
	#{group,jdbcType = VARCHAR },
	</if>
	<if test="cron!=null and cron !=''">
	#{cron,jdbcType = VARCHAR },
	</if>
	"ACQUIRED"
)
update task name=#{name,jdbcType = VARCHAR }, 
	<!-- className -->
	<if test="className !=null  and className !='' ">
		className=#{className,jdbcType = VARCHAR },
	</if>
	
	<!-- group -->
	<if test="group !=null  and group !='' ">
		`group`=#{group,jdbcType = VARCHAR },
	</if>
	
	<!-- cron -->
	<if test="cron !=null  and cron !='' ">
		cron=#{cron,jdbcType = VARCHAR },
	</if>		
		<!-- cron -->
	<if test="state !=null  and state !='' ">
		state=#{state,jdbcType = VARCHAR }
	</if>	
</set>
<where>
		quartzId=#{quartzId}
</where>
update task state="PAUSED" `group`=#{group} and name=#{name} 
	update task
<set>
		state="ACQUIRED"
</set>
<where>
	 	`group`=#{group} and
		 name=#{name} 
</where>
delete from task where quartzId in(

item=“quartzId” separator =",">
(
#{quartzId}
)
)

delete from task quartzId=#{quartzId}

package com.sr.config;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationListener;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.event.ContextRefreshedEvent;

import com.sr.entity.Task;
import com.sr.service.ScheduleJobService;
import com.sr.service.impl.TimingTaskService;

@Configuration
public class JobListener implements ApplicationListener {

@Autowired
ScheduleJobService ScheduleJobServiceImpl;
@Autowired
private TimingTaskService TimingTaskServiceImpl;
@Override
public void onApplicationEvent(ContextRefreshedEvent contextRefreshedEvent) {
     List<Task> tasks = TimingTaskServiceImpl.selectTask();
    //List<Task> tasks = new ArrayList<Task>();
    
    //tasks.add(new Task(1,"fen", "com.sr.service.impl.TestJob", "fen1", "0 */1 * * * ?"));
    System.out.println("task size = " + tasks.size());
    try {
        for (Task task : tasks) {
        	//ScheduleJobServiceImpl.addJob(task);
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

}

package com.sr.config;

import java.io.IOException;
import java.util.Properties;

import org.quartz.Scheduler;
import org.quartz.ee.servlet.QuartzInitializerListener;
import org.springframework.beans.factory.config.PropertiesFactoryBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.ClassPathResource;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;

@Configuration
public class QuartzConfig {

@Bean(name="SchedulerFactory")
public SchedulerFactoryBean schedulerFactoryBean() throws IOException {
	
	
	  PropertiesFactoryBean propertiesFactoryBean = new PropertiesFactoryBean();
	  propertiesFactoryBean.setLocation(new ClassPathResource("/quartz.properties"));
	    //在quartz.properties中的属性被读取并注入后再初始化对象
	  propertiesFactoryBean.afterPropertiesSet();
	    //创建SchedulerFactoryBean
	    
	   
	    
    SchedulerFactoryBean factory = new SchedulerFactoryBean();
    //factory.setQuartzProperties(quartzProperties());
    
    factory.setQuartzProperties(propertiesFactoryBean.getObject());
    return factory;
}

/*
 * quartz初始化监听器
 */
@Bean
public QuartzInitializerListener executorListener() {
    return new QuartzInitializerListener();
}

/*
 * 通过SchedulerFactoryBean获取Scheduler的实例
 */
@Bean(name="Scheduler")
public Scheduler scheduler() throws IOException {
    return schedulerFactoryBean().getScheduler();
}

/**
 * 设置quartz属性,可以从properties配置中读取
 */
public Properties quartzProperties() throws IOException {
    Properties prop = new Properties();
    prop.put("quartz.scheduler.instanceName", "ServerScheduler");
    prop.put("org.quartz.scheduler.instanceId", "AUTO");
    prop.put("org.quartz.scheduler.skipUpdateCheck", "true");
    prop.put("org.quartz.scheduler.instanceId", "NON_CLUSTERED");
    prop.put("org.quartz.scheduler.jobFactory.class", "org.quartz.simpl.SimpleJobFactory");
    prop.put("org.quartz.threadPool.class", "org.quartz.simpl.SimpleThreadPool");
    prop.put("org.quartz.threadPool.threadCount", "5");
    prop.put("org.quartz.threadPool.threadPriority", "5");
    //存入数据库表中
    prop.put("org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread", "true");
    prop.put("org.quartz.jobStore.misfireThreshold", "5000");
    prop.put("org.quartz.jobStore.class", "org.quartz.impl.jdbcjobstore.JobStoreTX");
    prop.put("org.quartz.jobStore.tablePrefix", "QRTZ_");
    prop.put("org.quartz.jobStore.dataSource", "sr");
    prop.put("org.quartz.dataSource.sr.driver", "com.mysql.jdbc.Driver");
    prop.put("org.quartz.dataSource.sr.URL", "jdbc:mysql://192.168.10.233:3306/edb?useUnicode=true&characterEncoding=UTF-8");
    prop.put("org.quartz.dataSource.sr.user", "root");
    prop.put("org.quartz.dataSource.sr.password", "tom");
    prop.put("org.quartz.dataSource.sr.maxConnection", "10");
  //设置数据源

    return prop;
}

}

quartz.scheduler.instanceName=ServerScheduler
org.quartz.scheduler.instanceId=AUTO
org.quartz.scheduler.skipUpdateCheck=true
org.quartz.scheduler.instanceId=NON_CLUSTERED
org.quartz.scheduler.jobFactory.class=org.quartz.simpl.SimpleJobFactory
org.quartz.threadPool.class=org.quartz.simpl.SimpleThreadPool
org.quartz.threadPool.threadCount=5
org.quartz.threadPool.threadPriority=5

org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread=true
org.quartz.jobStore.misfireThreshold=5000
org.quartz.jobStore.class=org.quartz.impl.jdbcjobstore.JobStoreTX
org.quartz.jobStore.tablePrefix=QRTZ_
org.quartz.jobStore.dataSource=sr
org.quartz.dataSource.sr.driver=com.mysql.jdbc.Driver
org.quartz.dataSource.sr.URL=jdbc:mysql://192.168.10.233:3306/edb?useUnicode=true&characterEncoding=UTF-8
org.quartz.dataSource.sr.user=root
org.quartz.dataSource.sr.password=tom
org.quartz.dataSource.sr.maxConnection=10

Bruno mars��
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java 定时任务spring_Spring 定时任务Scheduled 开发详细图文
weixin_35815036的博客
02-21 368
Spring 定时任务Scheduled 开发文章目录一、前言1.1 定时任务1.2 开发环境1.3 技术实现二、创建包含WEB.xml 的Maven 项目2.1 创建多模块项目taskproject2.2 配置task-web 子模块Add Web2.3 配置Tomcat 运行Web 项目三、定时任务开发3.1 配置Spring3.2 编写自动任务类3.3 运行项目验证定时任务一、前言1.1 定...
定时任务详解
热门推荐
qq_22162093的博客
10-13 1万+
定时任务
定时任务的书写流程是什么？Linux运维定时任务学习
oldboysecurity的博客
03-23 194
Linux运维基础学习中，关于定时任务了解多少呢？咱们今天就来简单了解下定时任务的书写流程。 一、定时任务的书写流程 1、为定时任务规则加必要的注释 2、执行shell脚本任务前加/bin/sh 3、定时任务命令或脚本的结尾加>/dev/null 2>&1或定向到一个文件 4、定时任务命令超过2条的命令执行，用脚本文件更好 5、在指定用户下执行相关的定时任务 6、生产任务程序不要随意的打印输出信息 1）定向到文件 2）>/dev/null 2>&1 7、定时任务执行的
定时任务流程图
weixin_37790352的博客
08-16 8443
  LogUploadTask MouldDownloadTask   PolicyHandleTask  
APScheduler定时任务框架（工作流程图、调度流程）、Job 作业、Trigger 触发器、Jobstore 任务存储器、Executor 执行器、date触发器、调度器、
最新发布
linjun的博客
03-25 1193
参考文章在日常工作中，如果想要简化工作流程实现办公自动化，那么几乎有大半的功能模块都需要使用定时任务，例如定时收发邮件，或者定时发微信或是检测垃圾邮件等等，而在python中常用实现定时任务的包含以下四种方法： while True : + sleep() threading . Timer定时器调度模块schedule任务框架APScheduler但在实际测试中，可以发现：循环 + sleep方式可以用来做简单测试。timer可以实现异步定时任务。
定时任务插件_K3Cloud定时任务插件_
09-30
对于K3Cloud的二次开发者，此插件提供了丰富的API接口，允许自定义任务逻辑，将企业特有的业务流程纳入定时任务体系。开发者可以通过编写脚本或者调用服务接口来实现复杂的任务逻辑，并通过插件进行调度。 3. **...
定时任务.zip
08-12
总的来说，"TimedTaskTool"作为一个专门的定时任务管理工具，能够帮助用户更高效地利用Windows的任务计划功能，提高工作流程自动化程度，减少手动操作，从而提高生产力。通过其易用性和丰富的功能，无论是个人还是...
定时任务实例
09-26
定时任务在IT行业中扮演着重要的角色，特别是在自动化和无人值守的工作流程中。它允许开发者预设一系列操作在特定时间或间隔自动执行，极大地提升了工作效率和系统的自动化程度。本实例聚焦于"定时任务"这一主题，将...
定时任务脚本制作
06-01
在IT领域，定时任务脚本是自动化工作流程中的重要组成部分，尤其在服务器管理和运维工作中扮演着不可或缺的角色。定时任务允许我们预设特定时间执行一系列操作，例如数据备份、日志清理、系统监控或发送报告等。本文...
spring定时任务
02-05
在Spring中，我们可以实现各种定时任务，以自动化执行特定的周期性操作。本篇文章将详细探讨Spring框架实现的三种定时任务方式：框架自带的Task Execution and Scheduling，Quartz Scheduler的集成以及使用注解进行...
Java定时执行某个任务
05-24
NULL 博文链接：https://penghuaiyi.iteye.com/blog/353669
TimingTask:一个做定时任务的库
06-18
定时任务 使用 AlarmManager 和 Broadcast 执行定时任务的库。 // Example I TimingTaskImp . getInstance( this ) . startTask( System . currentTimeMillis(), 60 * 1000 , new TimingTaskListener () { @Override public void doTask () { // TODO code here } }); // Example II TimingTaskImp . getInstance( this ) . startTask( System . currentTimeMillis(), new TimingTaskListener () { @Override public void doTask (
java Timer 定时任务（二）
UnknownZYB的博客
11-03 708
上篇文章介绍了模仿程序时出现的问题 下面是shell启动执行调度的一个简单流程图：
java定时任务的实现步骤
刘时懂的博客
01-03 414
java定时任务的实现步骤 1.启动加载定时任务，将需要的作业类加载进来 <bean id = "类别名A" class="全命名"></bean> 2.指定任务类，定义了一个任务JobDetail <bean id="类别名B" class="org.springframework.scheduling.quartz.MethodInvokingJobDetail...
定时任务方案
angel_zt的博客
09-25 846
@[定时相关说明文档] 1.创建普通定时 Android原生步骤 流程图： 说明： 1）查询设备所有schedule列表 public AylaAPIRequest fetchSchedules(final Response.Listener<AylaSchedule[]> successListener, ...
定时任务总结
古月--的博客
06-25 450
提到定时任务调度的时候，相信很多人会想到芹菜celery，要么就写个脚本塞到crontab中（参考我的另外一篇文章）。不过，一个小的定时脚本，要用celery的话太“重”了。所以，我找到了一个轻量级的定时任务调度的库：schedule和Timer。 crontab https://blog.csdn.net/weixin_40283480/article/details/79855140 #...
定时任务简单的3种实现方法
鑫和皓的博客
07-09 3264
本文介绍了简单的三种实现定时任务的方法，包括使用操作系统定时任务、使用第三方定时任务库以及使用编程语言自带的定时任务功能。其中，timer 对象用于调度定时任务的执行时间，calendar 对象用于设置定时任务的执行时间，new BackupTask() 创建一个 BackupTask 类的实例，用于执行备份数据库的操作。scheduleAtFixedRate() 方法用于添加定时任务，第一个参数为定时任务的实例，第二个参数为定时任务的开始时间，第三个参数为定时任务的间隔时间。
业务可视化-让你的流程图“Run“起来(6.定时任务&Spring-Batch的集成)
JHIII的博客
08-11 607
分享一下近期我对这个项目的一些改进。在项目中，经常会有一些批处理的定时任务需要配置，目前的java项目一般采用Spring-Batch来作为批处理的平台。但是Spring-Batch在对Job流程（并行，分支，条件分支，合并等）的支持略显复杂臃肿。尤其是流程可视化这方面几乎不支持。所以，最近对ladybugflow做了改进，在天然支持可视化流程的基础上，追加了对定时任务的支持。本篇文章介绍ladybugflow定时任务的配置，和与SpringBatch相结合完成批处理的可视化操作的例子。...
Flowable定时器与实时流程图
BASK2312的博客
12-10 940
category("javaboy的工作流分类").name("javaboy的工作流名称").key("javaboy的工作流key666");.deploy();return RespBean.ok("部署成功",deployment.getId());}}复制代码表示流程在延迟一分钟之后，才激活。
python 定时任务执行流程
07-29
Python中执行定时任务的流程通常如下： 1. 导入所需的模块：首先需要导入`schedule`模块，该模块提供了定时任务调度的功能，可以通过`pip install schedule`安装。 2. 定义定时任务函数：根据实际需求，编写定时...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值