### 回答1：
Spring Boot是一个轻量级的
Java web开发框架，而
Quartz是一个用于任务调度的高可靠性、高扩展性的开源工具。将两者整合起来，可以更方便地实现任务调度，本文就介绍一下关于Spring Boot2与
Quartz整合的Demo。
该Demo的主要功能包括任务添加、任务修改、任务移除以及任务查看。
首先，我们需要添加
Quartz的相关依赖，如下：
```xml
<!--
Quartz -->
<dependency>
<groupId>org.
quartz-scheduler</groupId>
<artifactId>
quartz</artifactId>
<version>2.3.2</version>
</dependency>
<dependency>
<groupId>org.
quartz-scheduler</groupId>
<artifactId>
quartz-jobs</artifactId>
<version>2.3.2</version>
</dependency>
<dependency>
<groupId>org.
quartz-scheduler</groupId>
<artifactId>
quartz-jobs-no-logging</artifactId>
<version>2.3.2</version>
</dependency>
```
然后，我们需要配置数据库，以
Quartz自带的表为例，可使用以下配置：
```yaml
spring:
datasource:
url: jdbc:mysql://localhost:3306/
quartz?useUnicode=true&characterEncoding=utf-8&useSSL=false
username: root
password: root
driver-class-name: com.mysql.jdbc.Driver
quartz:
scheduler:
instanceName:
quartzScheduler
instanceId: AUTO
jobStore:
class: org.
quartz.impl.jdbcjobstore.JobStoreTX
driverDelegateClass: org.
quartz.impl.jdbcjobstore.StdJDBCDelegate
tablePrefix: QRTZ_
isClustered: false
threadPool:
class: org.
quartz.simpl.SimpleThreadPool
threadCount: 5
threadPriority: 5
threadsInheritContextClassLoaderOfInitializingThread: true
```
接下来，我们需要创建一个JobDetail，用于指定需要执行的任务：
```
java
@Component
public class SomeJob extends
QuartzJobBean {
private String someParam;
public void setSomeParam(String someParam) {
this.someParam = someParam;
}
@Override
protected void executeInternal(JobExecutionContext jobExecutionContext) throws JobExecutionException {
// 任务执行逻辑
}
}
```
接下来，我们需要使用Cron
TriggerFactoryBean生成一个Cron
Trigger：
```
java
@Component
public class Cron
TriggerJob {
@Autowired
private Scheduler
quartzScheduler;
@Autowired
private SomeJob someJob;
public void start() throws Exception {
Cron
TriggerFactoryBean cron
TriggerFactoryBean = new Cron
TriggerFactoryBean();
cron
TriggerFactoryBean.setJobDetail(getJobDetail());
cron
TriggerFactoryBean.setCronExpression("0/5 * * * * ?");
cron
TriggerFactoryBean.setName("myCron
Trigger");
cron
TriggerFactoryBean.afterPropertiesSet();
Trigger trigger = cron
TriggerFactoryBean.getObject();
quartzScheduler.scheduleJob(getJobDetail(),
trigger);
}
private JobDetail getJobDetail() {
JobDetailFactoryBean jobDetailFactoryBean = new JobDetailFactoryBean();
jobDetailFactoryBean.setJobClass(SomeJob.class);
jobDetailFactoryBean.setName("myJobDetail");
jobDetailFactoryBean.setDescription("this is my job detail");
jobDetailFactoryBean.getJobDataMap().put("jobParam", "job param");
jobDetailFactoryBean.afterPropertiesSet();
return jobDetailFactoryBean.getObject();
}
}
```
接下来，我们需要配置一个
定时任务Controller，用于实现
定时任务的添加、修改、移除以及查看功能：
```
java
@RestController
public class
QuartzController {
private static final Logger logger = LoggerFactory.getLogger(
QuartzController.class);
@Autowired
private Scheduler
quartzScheduler;
/**
* 添加
定时任务
*/
@PostMapping("/addJob")
public void addJob(@RequestParam String jobName,
@RequestParam String jobGroup,
@RequestParam String cronExpression) {
try {
JobDetail jobDetail = JobBuilder.newJob(SomeJob.class)
.withIdentity(jobName, jobGroup)
.build();
Cron
Trigger trigger =
TriggerBuilder.new
Trigger()
.withIdentity(jobName, jobGroup)
.withSchedule(CronScheduleBuilder.cronSchedule(cronExpression))
.build();
quartzScheduler.scheduleJob(jobDetail,
trigger);
logger.info("add job success, jobName:{}, jobGroup:{}, cronExpression:{}", jobName, jobGroup, cronExpression);
} catch (SchedulerException e) {
logger.
error("add job
error, jobName:{}, jobGroup:{}, cronExpression:{}, e:{}", jobName, jobGroup, cronExpression, e.getMessage(), e);
}
}
/**
* 修改
定时任务
*/
@PostMapping("/modifyJob")
public void modifyJob(@RequestParam String jobName,
@RequestParam String jobGroup,
@RequestParam String cronExpression) {
try {
TriggerKey
triggerKey = new
TriggerKey(jobName, jobGroup);
Cron
Trigger old
Trigger = (Cron
Trigger)
quartzScheduler.get
Trigger(
triggerKey);
if (old
Trigger != null) {
Cron
Trigger new
Trigger =
TriggerBuilder.new
Trigger()
.withIdentity(jobName, jobGroup)
.withSchedule(CronScheduleBuilder.cronSchedule(cronExpression))
.startNow()
.build();
// 更新
定时任务
quartzScheduler.rescheduleJob(
triggerKey, new
Trigger);
logger.info("modify job success, jobName:{}, jobGroup:{}, cronExpression:{}", jobName, jobGroup, cronExpression);
}
} catch (SchedulerException e) {
logger.
error("modify job
error, jobName:{}, jobGroup:{}, cronExpression:{}, e:{}", jobName, jobGroup, cronExpression, e.getMessage(), e);
}
}
/**
* 移除
定时任务
*/
@PostMapping("/removeJob")
public void removeJob(@RequestParam String jobName,
@RequestParam String jobGroup) {
try {
TriggerKey
triggerKey = new
TriggerKey(jobName, jobGroup);
quartzScheduler.unscheduleJob(
triggerKey);
quartzScheduler.deleteJob(JobKey.jobKey(jobName, jobGroup));
logger.info("remove job success, jobName:{}, jobGroup:{}", jobName, jobGroup);
} catch (Exception e) {
logger.
error("remove job
error, jobName:{}, jobGroup:{}, e:{}", jobName, jobGroup, e.getMessage(), e);
}
}
/**
* 查看
定时任务
*/
@GetMapping("/listJob")
public List<Map<String, Object>> listJob() {
List<Map<String, Object>> list = new ArrayList<>();
try {
System.out.println(
quartzScheduler.getSchedulerName());
GroupMatcher<JobKey> matcher = GroupMatcher.anyJobGroup();
Set<JobKey> jobKeys =
quartzScheduler.getJobKeys(matcher);
for (JobKey jobKey : jobKeys) {
List<? extends
Trigger>
triggers =
quartzScheduler.get
TriggersOfJob(jobKey);
for (
Trigger trigger :
triggers) {
Map<String, Object> item = new HashMap<>();
JobDetail jobDetail =
quartzScheduler.getJobDetail(jobKey);
item.put("jobName", jobDetail.getKey().getName());
item.put("jobGroup", jobDetail.getKey().getGroup());
item.put("
triggerName",
trigger.getKey().getName());
item.put("
triggerGroup",
trigger.getKey().getGroup());
item.put("
triggerState",
quartzScheduler.get
TriggerState(
trigger.getKey()));
if (
trigger instanceof Simple
Trigger) {
Simple
Trigger simple
Trigger = (Simple
Trigger)
trigger;
item.put("startTime", simple
Trigger.getStartTime());
item.put("endTime", simple
Trigger.getEndTime());
}
if (
trigger instanceof Cron
Trigger) {
Cron
Trigger cron
Trigger = (Cron
Trigger)
trigger;
item.put("cronExpression", cron
Trigger.getCronExpression());
}
list.add(item);
}
}
} catch (SchedulerException e) {
logger.
error("list job
error, e:{}", e.getMessage(), e);
}
return list;
}
}
```
最后，我们需要在启动类上添加@Configuration注解，以确保程序能够正常运行：
```
java
@
SpringBootApplication
@Configuration
public class
QuartzDemoApplication {
public static void main(String[] args) {
SpringApplication.run(
QuartzDemoApplication.class, args);
}
// 启用
Quartz调度器
@Bean
public SchedulerFactoryBean schedulerFactoryBean() {
SchedulerFactoryBean schedulerFactoryBean = new SchedulerFactoryBean();
schedulerFactoryBean.setDataSource(dataSource);
schedulerFactoryBean.setAutoStartup(true);
schedulerFactoryBean.setWaitForJobsToCompleteOnShutdown(true);
schedulerFactoryBean.set
QuartzProperties(
quartzProperties());
return schedulerFactoryBean;
}
// 配置
Quartz属性
private Properties
quartzProperties() {
Properties properties = new Properties();
properties.put("org.
quartz.scheduler.instanceName", "
quartzScheduler");
properties.put("org.
quartz.scheduler.instanceId", "AUTO");
properties.put("org.
quartz.jobStore.driverDelegateClass", "org.
quartz.impl.jdbcjobstore.StdJDBCDelegate");
properties.put("org.
quartz.jobStore.dataSource", "
quartzDataSource");
properties.put("org.
quartz.jobStore.tablePrefix", "QRTZ_");
properties.put("org.
quartz.jobStore.isClustered", false);
properties.put("org.
quartz.threadPool.class", "org.
quartz.simpl.SimpleThreadPool");
properties.put("org.
quartz.threadPool.threadCount", "5");
properties.put("org.
quartz.threadPool.threadPriority", "5");
properties.put("org.
quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread", true);
return properties;
}
}
```
至此，一款功能完备的Spring Boot2与
Quartz整合Demo便完成了。
### 回答2：
以下是一个使用Spring Boot 2和
Quartz整合的简单示例：
首先，确保在你的项目中添加了以下依赖：
```xml
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-
quartz</artifactId>
</dependency>
```
然后，创建一个
Quartz配置类，用于配置
定时任务的调度器、触发器和任务：
```
java
@Configuration
public class
QuartzConfig {
@Autowired
private ApplicationContext applicationContext;
@Bean
public JobFactory jobFactory() {
AutowiringSpringBeanJobFactory jobFactory = new AutowiringSpringBeanJobFactory();
jobFactory.setApplicationContext(applicationContext);
return jobFactory;
}
@Bean
public Scheduler scheduler() throws SchedulerException {
SchedulerFactory schedulerFactory = new StdSchedulerFactory();
Scheduler scheduler = schedulerFactory.getScheduler();
scheduler.setJobFactory(jobFactory());
scheduler.start();
return scheduler;
}
}
```
接下来，创建一个
定时任务的示例类：
```
java
@Service
public class MyJob implements Job {
@Override
public void execute(JobExecutionContext context) throws JobExecutionException {
System.out.println("Hello
Quartz!");
}
}
```
然后，创建一个
定时任务管理器，用于添加、修改、移除和查找
定时任务：
```
java
@Component
public class JobManager {
@Autowired
private Scheduler scheduler;
public void addJob(String jobName, String jobGroup, String cronExpression) throws SchedulerException {
JobDetail jobDetail = JobBuilder.newJob(MyJob.class)
.withIdentity(jobName, jobGroup)
.build();
Trigger trigger =
TriggerBuilder.new
Trigger()
.withIdentity(jobName, jobGroup)
.withSchedule(CronScheduleBuilder.cronSchedule(cronExpression))
.build();
scheduler.scheduleJob(jobDetail,
trigger);
}
public void updateJob(String jobName, String jobGroup, String cronExpression) throws SchedulerException {
TriggerKey
triggerKey =
TriggerKey.
triggerKey(jobName, jobGroup);
Cron
Trigger trigger = (Cron
Trigger) scheduler.get
Trigger(
triggerKey);
trigger =
trigger.get
TriggerBuilder()
.withIdentity(
triggerKey)
.withSchedule(CronScheduleBuilder.cronSchedule(cronExpression))
.build();
scheduler.rescheduleJob(
triggerKey,
trigger);
}
public void deleteJob(String jobName, String jobGroup) throws SchedulerException {
JobKey jobKey = JobKey.jobKey(jobName, jobGroup);
scheduler.deleteJob(jobKey);
}
public List<Map<String, Object>> getAllJobs() throws SchedulerException {
List<Map<String, Object>> jobList = new ArrayList<>();
for (String groupName : scheduler.getJobGroupNames()) {
for (JobKey jobKey : scheduler.getJobKeys(GroupMatcher.jobGroupEquals(groupName))) {
Map<String, Object> job = new HashMap<>();
JobDetail jobDetail = scheduler.getJobDetail(jobKey);
job.put("name", jobDetail.getKey().getName());
job.put("group", jobDetail.getKey().getGroup());
Trigger trigger = scheduler.get
TriggersOfJob(jobKey).get(0);
job.put("cronExpression",
trigger instanceof Cron
Trigger ? ((Cron
Trigger)
trigger).getCronExpression() : "N/A");
jobList.add(job);
}
}
return jobList;
}
}
```
最后，创建一个控制器类，用于处理
定时任务的添加、修改、移除和查找请求：
```
java
@RestController
public class JobController {
@Autowired
private JobManager jobManager;
@PostMapping("/jobs")
public void addJob(@RequestParam String name, @RequestParam String group, @RequestParam String cronExpression) throws SchedulerException {
jobManager.addJob(name, group, cronExpression);
}
@PutMapping("/jobs")
public void updateJob(@RequestParam String name, @RequestParam String group, @RequestParam String cronExpression) throws SchedulerException {
jobManager.updateJob(name, group, cronExpression);
}
@DeleteMapping("/jobs")
public void deleteJob(@RequestParam String name, @RequestParam String group) throws SchedulerException {
jobManager.deleteJob(name, group);
}
@GetMapping("/jobs")
public List<Map<String, Object>> getAllJobs() throws SchedulerException {
return jobManager.getAllJobs();
}
}
```
现在，你可以运行应用程序并使用以下API进行
定时任务的添加、修改、移除和查找操作：
- 添加
定时任务：`POST /jobs?name=job1&group=group1&cronExpression=0/10 * * * * ?`
- 修改
定时任务：`PUT /jobs?name=job1&group=group1&cronExpression=0/30 * * * * ?`
- 移除
定时任务：`DELETE /jobs?name=job1&group=group1`
- 查找所有
定时任务：`GET /jobs`
这是一个简单的Spring Boot 2和
Quartz整合的示例，可以用于管理
定时任务的添加、修改、移除和查找操作。你可以根据自己的需求对代码进行进一步的调整和扩展。
### 回答3：
下面是一个以Spring Boot 2和
Quartz整合的简单示例：
1. 首先，你需要在pom.xml文件中添加以下依赖项来引入Spring Boot和
Quartz的库：
```xml
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-
quartz</artifactId>
</dependency>
```
2. 创建一个Spring Boot的启动类，并添加`@EnableScheduling`注解，以启用
定时任务的调度功能：
```
java
@
SpringBootApplication
@EnableScheduling
public class DemoApplication {
public static void main(String[] args) {
SpringApplication.run(DemoApplication.class, args);
}
}
```
3. 创建一个
定时任务的配置类，使用`@Configuration`注解标记，并注入`SchedulerFactoryBean`来创建
Quartz调度器：
```
java
@Configuration
public class
QuartzConfig {
@Bean
public SchedulerFactoryBean schedulerFactoryBean() {
SchedulerFactoryBean schedulerFactoryBean = new SchedulerFactoryBean();
// 添加其他配置，如数据源设置等
return schedulerFactoryBean;
}
}
```
4. 创建一个
定时任务类，使用`@Component`注解标记，并使用`@Scheduled`注解指定
定时任务的执行时间。同时，你还可以使用`@Async`注解来异步执行任务。
```
java
@Component
public class MyJob {
@Scheduled(cron = "0/5 * * * * ?") // 每隔5秒执行一次
public void doJob() {
//
定时任务执行的逻辑代码
}
}
```
现在，你的Spring Boot应用已经整合了
Quartz，并且可以添加、修改、移除
定时任务了。在控制台中你可以通过查看
Quartz的日志来确认
定时任务是否正常执行。
在Java项目中使用Quartz进行定时任务调度时遇到问题，某些任务状态异常变为ERROR。经排查，发现由于两个服务实例运行同一数据库导致。老版本服务因找不到相应job类而引发错误。解决方案是检查数据库中的服务进程，更新代码或关闭旧服务，确保代码一致性。
扫一扫
2914
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
