10.1 pom.xml添加如下配置:
<!-- quartz定时任务 -->
<dependency>
<groupId>org.quartz-scheduler</groupId>
<artifactId>quartz</artifactId>
</dependency>
10.2 resources目录增加配置文件quartz.properties
# thread-pool
org.quartz.threadPool.class=org.quartz.simpl.SimpleThreadPool
org.quartz.threadPool.threadCount=10
# job-store
org.quartz.jobStore.class=org.quartz.simpl.RAMJobStore
10.3 Quartz定时任务例子
1. 数据库创建定时任务调度表
CREATE TABLE `job_config` (
`id` INT(11) NOT NULL AUTO_INCREMENT,
`create_time` DATETIME DEFAULT NULL,
`cron_time` VARCHAR(50) NOT NULL COMMENT '执行时间 例:0/8 * * * * ?',
`full_entity` VARCHAR(255) NOT NULL COMMENT '任务类全路径',
`group_name` VARCHAR(100) NULL COMMENT '任务组名称',
`name` VARCHAR(100) NOT NULL COMMENT '任务名',
`status` VARCHAR(2) NOT NULL COMMENT '任务状态，0-无效 1-有效',
`update_time` DATETIME DEFAULT NULL,
`remark` VARCHAR(255) NOT NULL COMMENT '备注',
PRIMARY KEY (`id`),
UNIQUE KEY `group_name` (`group_name`,`name`)
)
DEFAULT CHARSET = utf8;
INSERT INTO `job_config` (`create_time`, `cron_time`, `full_entity`, `group_name`, `name`, `status`, `update_time`, `remark`) VALUES (now(), '0/7 * * * * ?', 'com.smallbss.quartz.CallEPCJob', 'instructions', 'call_ecp', '1', now(),'定时发指令');
2. <!--[endif]-->配置config启动定时任务
QuartzConfig类：
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.quartz.impl.StdSchedulerFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import java.util.List;
@Configuration
public class QuartzConfig {
Logger logger = LoggerFactory.getLogger(getClass());
@Autowired
private ApplicationContext applicationContext;
@Autowired
private QuartzConfigService quartzConfigService;
@Bean
public StdSchedulerFactory stdSchedulerFactory() {
StdSchedulerFactory stdSchedulerFactory = new StdSchedulerFactory();
// 获取JobConfig集合
List<QuartzBean> quartzList = quartzConfigService.findAllByStatus(1);
logger.debug("Setting the Scheduler up");
for (QuartzBean quartz : quartzList) {
try {
Boolean flag = SchedulerUtil.createScheduler(quartz, applicationContext);
logger.info("quartz job " + quartz.getName() + " Path:" + quartz.getFullEntity() + " start... 执行结果："
+ flag);
} catch (Exception e) {
e.printStackTrace();
}
}
return stdSchedulerFactory;
}
}
SchedulerUtil 类：
import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.core.io.ClassPathResource;
import org.springframework.scheduling.quartz.CronTriggerFactoryBean;
import org.springframework.scheduling.quartz.JobDetailFactoryBean;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;
import java.text.ParseException;
public class SchedulerUtil {
// 定时任务Scheduler的工厂类，Quartz提供
private static StdSchedulerFactory schedulerFactory = new StdSchedulerFactory();
// CronTrigger的工厂类
private static CronTriggerFactoryBean factoryBean = new CronTriggerFactoryBean();
// JobDetail的工厂类
private static JobDetailFactoryBean jobDetailFactory = new JobDetailFactoryBean();
// 自动注入Spring Bean的工厂类
private static AutoWiringSpringBeanJobFactory jobFactory = new AutoWiringSpringBeanJobFactory();
// 定时任务Scheduler的工厂类，Spring Framework提供
private static SchedulerFactoryBean schedulerFactoryBean = new SchedulerFactoryBean();
static {
// 加载指定路径的配置
schedulerFactoryBean.setConfigLocation(new ClassPathResource("quartz.properties"));
}
/**
* 创建定时任务，根据参数，创建对应的定时任务，并使之生效
*
* @param config
* @param context
* @return
*/
public static boolean createScheduler(QuartzBean config, ApplicationContext context) {
try {
// 创建新的定时任务
return create(config, context);
} catch (Exception e) {
e.printStackTrace();
}
return false;
}
/**
* 删除旧的定时任务，创建新的定时任务
*
* @param oldConfig
* @param config
* @param context
* @return
*/
public static Boolean modifyScheduler(QuartzBean oldConfig, QuartzBean config, ApplicationContext context) {
if (oldConfig == null || config == null || context == null) {
return false;
}
try {
String oldJobClassStr = oldConfig.getFullEntity();
String oldName = oldJobClassStr + oldConfig.getId();
String oldGroupName = oldConfig.getGroupName();
// 1、清除旧的定时任务
delete(oldName, oldGroupName);
// 2、创建新的定时任务
return create(config, context);
} catch (SchedulerException e) {
e.printStackTrace();
} catch (Exception e) {
e.printStackTrace();
}
return false;
}
/**
* 提取的删除任务的方法
*
* @param oldName
* @param oldGroupName
* @return
* @throws SchedulerException
*/
private static Boolean delete(String oldName, String oldGroupName) throws SchedulerException {
TriggerKey key = new TriggerKey(oldName, oldGroupName);
Scheduler oldScheduler = schedulerFactory.getScheduler();
// 根据TriggerKey获取trigger是否存在，如果存在则根据key进行删除操作
Trigger keyTrigger = oldScheduler.getTrigger(key);
if (keyTrigger != null) {
oldScheduler.unscheduleJob(key);
}
return true;
}
/**
* 提取出的创建定时任务的方法
*
* @param config
* @param context
* @return
*/
private static Boolean create(QuartzBean config, ApplicationContext context) {
try {
// 创建新的定时任务
String jobClassStr = config.getFullEntity();
Class clazz = Class.forName(jobClassStr);
String name = jobClassStr + config.getId();
String groupName = config.getGroupName();
String description = config.toString();
String time = config.getCronTime();
JobDetail jobDetail = createJobDetail(clazz, name, groupName, description);
if (jobDetail == null) {
return false;
}
Trigger trigger = createCronTrigger(jobDetail, time, name, groupName, description);
if (trigger == null) {
return false;
}
jobFactory.setApplicationContext(context);
schedulerFactoryBean.setJobFactory(jobFactory);
schedulerFactoryBean.setJobDetails(jobDetail);
schedulerFactoryBean.setTriggers(trigger);
schedulerFactoryBean.afterPropertiesSet();
Scheduler scheduler = schedulerFactoryBean.getScheduler();
if (!scheduler.isShutdown()) {
scheduler.start();
}
return true;
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (SchedulerException e) {
e.printStackTrace();
} catch (Exception e) {
e.printStackTrace();
}
return false;
}
/**
* 根据指定的参数，创建JobDetail
*
* @param clazz
* @param name
* @param groupName
* @param description
* @return
*/
public static JobDetail createJobDetail(Class clazz, String name, String groupName, String description) {
jobDetailFactory.setJobClass(clazz);
jobDetailFactory.setName(name);
jobDetailFactory.setGroup(groupName);
jobDetailFactory.setDescription(description);
jobDetailFactory.setDurability(true);
jobDetailFactory.afterPropertiesSet();
return jobDetailFactory.getObject();
}
/**
* 根据参数，创建对应的CronTrigger对象
*
* @param job
* @param time
* @param name
* @param groupName
* @param description
* @return
*/
public static CronTrigger createCronTrigger(JobDetail job, String time, String name, String groupName,
String description) {
factoryBean.setName(name);
factoryBean.setJobDetail(job);
factoryBean.setCronExpression(time);
factoryBean.setDescription(description);
factoryBean.setGroup(groupName);
try {
factoryBean.afterPropertiesSet();
} catch (ParseException e) {
e.printStackTrace();
}
return factoryBean.getObject();
}
}
AutoWiringSpringBeanJobFactory类：
import org.quartz.spi.TriggerFiredBundle;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.scheduling.quartz.SpringBeanJobFactory;
public final class AutoWiringSpringBeanJobFactory extends SpringBeanJobFactory implements ApplicationContextAware {
private transient AutowireCapableBeanFactory beanFactory;
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
beanFactory = applicationContext.getAutowireCapableBeanFactory();
}
@Override
protected Object createJobInstance(final TriggerFiredBundle bundle) throws Exception {
final Object job = super.createJobInstance(bundle);
beanFactory.autowireBean(job);
return job;
}
}
QuartzBean 类
import java.util.Date;
public class QuartzBean {
private Integer id;
private String name;
private String fullEntity;
private String groupName;
private String cronTime;
private String status;
private Date createTime;
private Date updateTime;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getFullEntity() {
return fullEntity;
}
public void setFullEntity(String fullEntity) {
this.fullEntity = fullEntity;
}
public String getGroupName() {
return groupName;
}
public void setGroupName(String groupName) {
this.groupName = groupName;
}
public String getCronTime() {
return cronTime;
}
public void setCronTime(String cronTime) {
this.cronTime = cronTime;
}
public String getStatus() {
return status;
}
public void setStatus(String status) {
this.status = status;
}
public Date getCreateTime() {
return createTime;
}
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
public Date getUpdateTime() {
return updateTime;
}
public void setUpdateTime(Date updateTime) {
this.updateTime = updateTime;
}
}
QuartzConfigService 类：
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@Service
public class QuartzConfigService {
@Autowired
private CommonService cs;
public List<QuartzBean> findAllByStatus(Integer status) {
String sql = "select * from job_config where status='1'";
return MapToJobConfigList(cs.queryBySql(sql));
}
public List<QuartzBean> MapToJobConfigList(List<Map<String, Object>> list) {
List<QuartzBean> jobList = new ArrayList<QuartzBean>();
QuartzBean quartzBean = null;
for (Map<String, Object> map : list) {
quartzBean = new QuartzBean();
quartzBean.setId((Integer) map.get("id"));
quartzBean.setCreateTime((Date) map.get("create_time"));
quartzBean.setCronTime((String) map.get("cron_time"));
quartzBean.setFullEntity((String) map.get("full_entity"));
quartzBean.setGroupName((String) map.get("group_name"));
quartzBean.setName((String) map.get("name"));
quartzBean.setStatus((String) map.get("status"));
quartzBean.setUpdateTime((Date) map.get("update_time"));
jobList.add(quartzBean);
}
return jobList;
}
}
CallEPCJob 类：
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
public class CallEPCJob implements Job {
@Autowired
private Logger logger=LoggerFactory.getLogger(CallEPCJob.class);
public void execute(JobExecutionContext context) {
logger.info("-----CallEPCJob--------");
}
}
相关推荐
Quartz Scheduler的Spring-Boot自动配置只是Quartz Scheduler的Spring-Boot启动器。 当然，Quartz Scheduler已经有好几个启动器，但是它们都不能满足我的所有需求，因此我创建了自己的启动器。 这只是一个业余项目。...
springboot+quartz 动态化配置，可在页面操作，查看、添加、修改、删除，暂停等操作
Spring Boot Quartz Scheduler示例：构建电子邮件调度应用 完整的教程： : 要求 Java-1.8.x Maven-3.xx MySQL-5.xx 设定步骤 1.克隆应用程序 git clone ...
该项目包含helloworld(快速入门)、web(ssh项目快速搭建）、aop(切面编程)、data-redis(redis缓存)、quartz(集群任务实现)、shiro（权限管理）、oauth2（四种认证模式）、shign(接口参数防篡改重放）、encoder（用户...
在Spring Boot中，可以使用多种方式来实现任务管理。 使用Java自带的定时任务库： 1.在Spring Boot中，你可以使用@Scheduled注解来创建定时任务。将@Scheduled注解与方法一起使用，指定任务执行的时间表达式。 2....
基于spring boot任务管理系统源代码 启动说明 项目使用的数据库为MySql，选择resources/sql中的tables_mysql_innodb.sql文件初始化数据库信息。 在resources/application.properties 以及quartz.properties文件中...
本案例实现的功能是SpringBoot整合Quartz定时任务框架，实现在项目运行过程中自动执行工作任务，设定时间是每20秒执行一次。
crystal-demo：用于Spring Boot 2和Quartz Scheduler集成的演示项目
39. Quartz Scheduler 40. Spring Integration 41. Spring Session 42. Monitoring and Management over JMX 43. Testing 43.1. Test Scope Dependencies 43.2. Testing Spring Applications 43.3. Testing Spring ...
定时器集成包，spring3.0+quartz1.0，http://blog.csdn.net/dzy21
training-boot-schedulerspring boot integrate scheduler job 该项目在Spring-Boot基础上整合了调度作业功能，演示了两种功能:注解配置使用配置文件XML这两种配置方式都有优势，如果需求固定，推荐使用注解，注解...
Quartz 是一个完全由 Java 编写的开源作业调度框架，为在 Java 应用程序中进行作业调度提供了简单却强大的机制。 Quartz 可以与 J2EE 与 J2SE 应用程序相结合也可以单独使用。 Quartz 允许程序开发人员根据时间的...
基于quartz实现分布式任务调度（定时、API）；引入camunda作为任务执行框架，支持工作流式任务编排、并发批量调度和参数传递。 简介 分布式、多租户的支持流程编排的任务调度应用 同时支持Redis分布式锁和Quartz...
基于Spring Cloud的微服务实战 - 天气...Spring Boot Web Starter 2.0.0.M4 Apache HttpClient 4.5.3 Spring Boot Data Redis Starter 2.0.0.M4 Redis 3.2.100 Spring Boot Quartz Starter 2.0.0.M4 Quartz Scheduler
Spring Boot + Quartz + Angular2演示应用程序。 它说明了如何安排cron作业，如何暂停作业，恢复作业，编辑石英作业等。它使用PostgreSQL作为存储石英作业和触发器的数据库。 详细说明： : 它包含基于Angular2...
本案例采用SpringBoot+Quartz实现了多个定时任务同时调度执行，运行测试通过，案例只编写了2个任务，如果要加更多任务，按注释添加即可。
spring boot和任务调度的整合（自由控制任务开启关闭） 以下为配置文件 # 固定前缀org.quartz # 主要分为scheduler、threadPool、jobStore、dataSource等部分 #==================================================...
Springboot学习示例 博客文章链接 （15）Spring Boot2.0 和邮件 （16）Spring Boot2.0 整合Spring Security （17）Spring Boot2.0 整合Shiro （18）Spring Boot2.0 与监控管理
SpringBoot 集成 Quartz 实现可控的任务 建立数据库，运行脚本，数据库sql脚本位于 quartz\src\main\resources\schema\schema-mysql.sql。 修改Spring boot配置文件相应的数据库连接参数。 运行Spring-Boot项目。 ...
12.1、使用@Scheduled创建定时任务 47 12.2、使用@Async实现异步调用 47 12.3、自定义参数 49 12.4、多环境配置 50 12.5、修改端口号 50 12.6、SpringBoot yml 使用 50 12.7、SpringBoot整合拦截器 51 12.8、...