说明：该定时任务架构：springboot + mybatis + mysql + 独立模块
业务逻辑：
1.时间写在数据库，便于修改
2.在执行任务的方法上加定时刷新注解
3.方法内去数据库中获取定时，然后与当前定时做比较，如果相同不做改变；如果不相同修改定时
pom.xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.hxh</groupId>
<artifactId>demo</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>jar</packaging>
<name>demo</name>
<description>Demo project for Spring Boot</description>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.0.2.RELEASE</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
<java.version>1.8</java.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-freemarker</artifactId>
</dependency>
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>1.3.2</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<scope>5.1.0</scope>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<!-- https://mvnrepository.com/artifact/com.alibaba/druid -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.0.31</version>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.31</version>
</dependency>
<dependency>
<groupId>org.quartz-scheduler</groupId>
<artifactId>quartz</artifactId>
<version>2.2.1</version>
</dependency>
<dependency>
<groupId>org.quartz-scheduler</groupId>
<artifactId>quartz-jobs</artifactId>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context-support</artifactId>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>application.properties
spring.datasource.name=com.alibaba.druid.pool.DruidDataSource
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/db_01?useSSL=false
spring.datasource.username=root
spring.datasource.password=hxh123456
mybatis.mapper-locations=classpath:mapper/*.xml
server.port=80
logging.level.root=INFO logging.level.org.hibernate=INFO logging.level.org.hibernate.type.descriptor.sql.BasicBinder=TRACE logging.level.org.hibernate.type.descriptor.sql.BasicExtractor=TRACE logging.level.com.itmuch=DEBUG定时任务工厂类
package com.example.demo.config;
import org.quartz.Trigger;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.quartz.CronTriggerFactoryBean;
import org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;
import com.example.demo.task.ScheduleTask;
@Configuration
public class QuartzConfigration {
/** * * @param task 需要執行的任務 * @return 定时任务工厂类 */
@Bean(name = "jobDetail")
public MethodInvokingJobDetailFactoryBean detailFactoryBean(ScheduleTask task) {
MethodInvokingJobDetailFactoryBean jobDetailFactoryBean = new MethodInvokingJobDetailFactoryBean();
/* * 是否并发执行 * 例如每5s执行一次任务，但是当前任务还没有执行完，就已经过了5s了， * 如果此处为true，则下一个任务会执行，如果此处为false，则下一个任务会等待上一个任务执行完后，再开始执行 */
jobDetailFactoryBean.setConcurrent(false);
jobDetailFactoryBean.setName("detail-name");//设置任务名字
jobDetailFactoryBean.setGroup("a1");//设置任务分组，，这些属性都可以存储在数据库中，在多任务的时候使用
jobDetailFactoryBean.setTargetObject(task);//为需要执行的实体类对应的对象
jobDetailFactoryBean.setTargetMethod("sing");//需要执行task类中的方法
return jobDetailFactoryBean;
}
/** * Details：配置定时任务的触发器，也就是什么时候触发执行定时任务 * @param jobDetailFactoryBean * @return */
@Bean(name = "jobTrigger")
public CronTriggerFactoryBean cronJobTrigger(MethodInvokingJobDetailFactoryBean jobDetailFactoryBean) {
CronTriggerFactoryBean triggerFactoryBean = new CronTriggerFactoryBean();
triggerFactoryBean.setJobDetail(jobDetailFactoryBean.getObject());
triggerFactoryBean.setCronExpression("0 30 20 * * ?");// 初始时的cron表达式
triggerFactoryBean.setName("detail-name");
return triggerFactoryBean;
}
/** * * @param trigger * @return */
@Bean(name = "scheduler")
public SchedulerFactoryBean schedulerFactory(Trigger trigger) {
SchedulerFactoryBean bean = new SchedulerFactoryBean();
// 用于quartz集群,QuartzScheduler 启动时更新己存在的Job
bean.setOverwriteExistingJobs(true);
// 延时启动，应用启动1秒后
bean.setStartupDelay(1);
// 注册触发器
bean.setTriggers(trigger);
return bean;
}
}定时任务刷新定时类
package com.example.demo.task;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.forwardedUrl;
import java.io.IOException;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLConnection;
import javax.annotation.Resource;
import javax.net.ssl.HttpsURLConnection;
import org.quartz.CronScheduleBuilder;
import org.quartz.CronTrigger;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.Scheduled;
importorg.springframework.stereotype.Component;
import com.example.demo.dao.QuartzDao;
import com.example.demo.entity.Config;
@Configuration
@EnableScheduling
@Component
public class ScheduleRefreshDatabase {
@Autowired
private QuartzDao dao;
@Resource(name = "jobDetail")
private JobDetail jobDetail;
@Resource(name = "jobTrigger")
private CronTrigger cronTrigger;
@Resource(name = "scheduler")
private Scheduler scheduler;
@Scheduled(fixedRate = 30000)
public void scheduleUpdateCronTrigger() throws SchedulerException, IOException {
CronTrigger trigger = (CronTrigger) scheduler.getTrigger(cronTrigger.getKey());
String currentCron = trigger.getCronExpression();
Config config = new Config();
config.setId(1l);
String searchCron = dao.findCron(config);
// System.out.println(currentCron);
// System.out.println(searchCron);
if (currentCron.equals(searchCron)) {
// URL url = new URL("http://localhost:8080/ssmredis2/redis/refurbish");
// URLConnection openConnection = url.openConnection();
// openConnection.connect();
// InputStream inputStream = openConnection.getInputStream();
// inputStream.close();
// URL url2 = openConnection.getURL();
// System.out.println(url2);
} else {
// 表达式调度构建器
CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(searchCron);
// 按新的cronExpression表达式重新构建trigger
trigger = (CronTrigger) scheduler.getTrigger(cronTrigger.getKey());
trigger = trigger.getTriggerBuilder().withIdentity(cronTrigger.getKey())
.withSchedule(scheduleBuilder).build();
// 按新的trigger重新设置job执行
scheduler.rescheduleJob(cronTrigger.getKey(), trigger);
currentCron = searchCron;
}定时任务方法实现类
package com.example.demo.task;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.stereotype.Component;
@Configuration
@Component
@EnableScheduling
public class ScheduleTask {
private static Logger LOGGER = LoggerFactory.getLogger(ScheduleTask.class);
public void sing() {
LOGGER.info("Hello world, i'm sing a song!!!");
}
}