Spring Boot 2.4 集成定时任务 Quartz 单机模式以及集群模式

最新推荐文章于 2024-07-31 19:51:02 发布
最新推荐文章于 2024-07-31 19:51:02 发布
阅读量3.9k 收藏 11
点赞数 3
分类专栏： Java 文章标签： springboot quartz spring cloud 定时任务 分布式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Mrqiang9001/article/details/110199328
版权

文章目录

​
​

1 摘要

Quartz 作为经典的定时任务框架，有这广泛的应用，支持集群模式。本文将介绍基于 Spring Boot 2.4 集成 Quart 单机模式和集群模式。

Quart 官方文档: http://www.quartz-scheduler.org/documentation

Quartz 数据库表脚本文件: 下载官网压缩包，解压后在 ./quartz-2.4.0-SNAPSHOT/src/org/quartz/impl/jdbcjobstore 目录下找到对应的数据库脚本

​

2 单机模式

2.1 核心 Maven 依赖

./demo-schedule-quartz/pom.xml

        <!-- Quartz 定时任务 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-quartz</artifactId>
            <version>${springboot.version}</version>
        </dependency>

其中 ${springboot.version} 的版本为 2.4.0

2.2 核心代码

2.2.1 定时执行的业务代码
./demo-schedule-quartz/src/main/java/com/ljq/demo/springboot/quartz/service/UserService.java

package com.ljq.demo.springboot.quartz.service;

/**
 * @Description: 用户业务层接口
 * @Author: junqiang.lu
 * @Date: 2020/11/14
 */
public interface UserService {

    /**
     * 查询所有用户数量
     *
     * @return
     */
    int countAll();
}

./demo-schedule-quartz/src/main/java/com/ljq/demo/springboot/quartz/service/impl/UserServiceImpl.java

package com.ljq.demo.springboot.quartz.service.impl;

import com.ljq.demo.springboot.quartz.service.UserService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.Random;

/**
 * @Description: 用户业务层实现类
 * @Author: junqiang.lu
 * @Date: 2020/11/14
 */
@Slf4j
@Service("userService")
@Transactional(rollbackFor = {Exception.class})
public class UserServiceImpl implements UserService {

    /**
     * 查询所有用户数量
     *
     * @return
     */
    @Override
    public int countAll() {
        int count = Math.abs(new Random().nextInt());
        log.debug("用户总数为: {}", count);
        return count;
    }
}

​

2.2.2 定时任务负载类
./demo-schedule-quartz/src/main/java/com/ljq/demo/springboot/quartz/job/UserJob.java

package com.ljq.demo.springboot.quartz.job;

import com.ljq.demo.springboot.quartz.service.UserService;
import lombok.extern.slf4j.Slf4j;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.quartz.QuartzJobBean;

import java.util.concurrent.atomic.AtomicInteger;

/**
 * @Description: 用户模块工作负载
 * @Author: junqiang.lu
 * @Date: 2020/11/14
 */
@Slf4j
public class UserJob extends QuartzJobBean {

    @Autowired
    private UserService userService;

    private final AtomicInteger counts = new AtomicInteger();

    @Override
    protected void executeInternal(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        log.debug("【定时任务】第【{}】次执行，用户总数:{}", counts.incrementAndGet(), userService.countAll());
    }
}

./demo-schedule-quartz/src/main/java/com/ljq/demo/springboot/quartz/job/UserJob2.java

package com.ljq.demo.springboot.quartz.job;

import lombok.extern.slf4j.Slf4j;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.scheduling.quartz.QuartzJobBean;

/**
 * @Description: 用户工作负载2
 * @Author: junqiang.lu
 * @Date: 2020/11/14
 */
@Slf4j
public class UserJob2 extends QuartzJobBean {
    @Override
    protected void executeInternal(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        log.debug("------定时任务开始执行-------");
    }
}

​

2.2.3 定时任务配置类
./demo-schedule-quartz/src/main/java/com/ljq/demo/springboot/quartz/common/config/QuartzScheduleConfig.java

package com.ljq.demo.springboot.quartz.common.config;

import com.ljq.demo.springboot.quartz.job.UserJob;
import com.ljq.demo.springboot.quartz.job.UserJob2;
import org.quartz.*;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @Description: Quartz 定时任务配置信息
 * @Author: junqiang.lu
 * @Date: 2020/11/14
 */
@Configuration
public class QuartzScheduleConfig {

    public static class UserJobConfig {

        /**
         * 工作负载名称
         */
        private static final String JOB_NAME = "userJob";
        /**
         * 触发器名称
         */
        private static final String TRIGGER_NAME = "userJobTrigger";

        @Bean
        public JobDetail userJob() {
            return JobBuilder.newJob(UserJob.class)
                    .withIdentity(JOB_NAME)
                    .storeDurably()
                    .build();
        }

        @Bean
        public Trigger userJobTrigger(){
            SimpleScheduleBuilder scheduleBuilder = SimpleScheduleBuilder.simpleSchedule()
                    .withIntervalInSeconds(5)
                    .repeatForever();
            return TriggerBuilder.newTrigger()
                    .forJob(JOB_NAME)
                    .withIdentity(TRIGGER_NAME)
                    .withSchedule(scheduleBuilder)
                    .build();
        }

    }

    public static class UserJob2Config {

        /**
         * 工作负载名称
         */
        private static final String JOB_NAME = "userJob2";
        /**
         * cron 表达式
         */
        private static final String CRON_EXP = "0/10 * * * * ? *";
        /**
         * 触发器名称
         */
        private static final String TRIGGER_NAME = "userJob2Trigger";

        @Bean
        public JobDetail userJob2() {
            return JobBuilder.newJob(UserJob2.class)
                    .withIdentity(JOB_NAME)
                    .storeDurably()
                    .build();
        }

        @Bean
        public Trigger userJob2Trigger() {
            CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(CRON_EXP);
            return TriggerBuilder.newTrigger()
                    .forJob(JOB_NAME)
                    .withIdentity(TRIGGER_NAME)
                    .withSchedule(scheduleBuilder)
                    .build();
        }

    }
}

​

2.2.4 SpringBoot 启动类
./demo-schedule-quartz/src/main/java/com/ljq/demo/springboot/quartz/DemoScheduleQuartzApplication.java

package com.ljq.demo.springboot.quartz;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * @author junqiang.lu
 */
@SpringBootApplication
public class DemoScheduleQuartzApplication {

    public static void main(String[] args) {
        SpringApplication.run(DemoScheduleQuartzApplication.class, args);
    }

}

2.3 application.yml 配置文件

./demo-schedule-quartz/src/main/resources/application.yml

## spring config
spring:
  quartz:
    scheduler-name: userSchedule
    job-store-type: memory
    auto-startup: true
    startup-delay: 1s
    wait-for-jobs-to-complete-on-shutdown: true
    overwrite-existing-jobs: false
    properties:
      org:
        quartz:
          threadPool:
            threadCount: 25
            threadPriority: 5
            class: org.quartz.simpl.SimpleThreadPool

配置信息参考官方文档: http://www.quartz-scheduler.org/documentation/2.4.0-SNAPSHOT/configuration.html

​

​

2.4 运行日志

2020-11-25 19:48:15 | DEBUG | userSchedule_Worker-1 | org.quartz.core.JobRunShell 201| Calling execute on job DEFAULT.userJob
2020-11-25 19:48:15 | DEBUG | userSchedule_Worker-1 | c.l.d.s.quartz.service.impl.UserServiceImpl 28| 用户总数为: 2034175457
2020-11-25 19:48:15 | DEBUG | userSchedule_Worker-1 | com.ljq.demo.springboot.quartz.job.UserJob 27| 【定时任务】第【1】次执行，用户总数:2034175457
2020-11-25 19:48:18 | DEBUG | userSchedule_Worker-2 | org.quartz.core.JobRunShell 201| Calling execute on job DEFAULT.userJob
2020-11-25 19:48:18 | DEBUG | userSchedule_QuartzSchedulerThread | org.quartz.core.QuartzSchedulerThread 291| batch acquisition of 1 triggers
2020-11-25 19:48:18 | DEBUG | userSchedule_Worker-2 | c.l.d.s.quartz.service.impl.UserServiceImpl 28| 用户总数为: 1515972786
2020-11-25 19:48:18 | DEBUG | userSchedule_Worker-2 | com.ljq.demo.springboot.quartz.job.UserJob 27| 【定时任务】第【1】次执行，用户总数:1515972786
2020-11-25 19:48:20 | DEBUG | userSchedule_QuartzSchedulerThread | org.quartz.core.QuartzSchedulerThread 291| batch acquisition of 1 triggers
2020-11-25 19:48:20 | DEBUG | userSchedule_Worker-3 | org.quartz.core.JobRunShell 201| Calling execute on job DEFAULT.userJob2
2020-11-25 19:48:20 | DEBUG | userSchedule_Worker-3 | com.ljq.demo.springboot.quartz.job.UserJob2 17| ------定时任务开始执行-------
2020-11-25 19:48:23 | DEBUG | userSchedule_QuartzSchedulerThread | org.quartz.core.QuartzSchedulerThread 291| batch acquisition of 1 triggers
2020-11-25 19:48:23 | DEBUG | userSchedule_Worker-4 | org.quartz.core.JobRunShell 201| Calling execute on job DEFAULT.userJob
2020-11-25 19:48:23 | DEBUG | userSchedule_Worker-4 | c.l.d.s.quartz.service.impl.UserServiceImpl 28| 用户总数为: 807472199
2020-11-25 19:48:23 | DEBUG | userSchedule_Worker-4 | com.ljq.demo.springboot.quartz.job.UserJob 27| 【定时任务】第【1】次执行，用户总数:807472199

​

3 集群模式

3.1 核心 Maven 依赖

./demo-schedule-quartz-group/pom.xml

        <!-- Quartz 定时任务 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-quartz</artifactId>
            <version>${springboot.version}</version>
        </dependency>
        <!-- mysql -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <!-- jdbc -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
            <version>${springboot.version}</version>
        </dependency>

其中 ${springboot.version} 的版本为 2.4.0

3.2 核心代码

3.2.1 定时任务业务代码

与单机模式一致

./demo-schedule-quartz-group/src/main/java/com/ljq/demo/springboot/quartz/group/service/UserService.java
./demo-schedule-quartz-group/src/main/java/com/ljq/demo/springboot/quartz/group/service/impl/UserServiceImpl.java

​

3.2.2 定时任务负载类

基本与单机模式一致，但是在类上添加了 @DisallowConcurrentExecution 注解，意为禁止并发运行,从而保证了在集群环境中，定时任务一次只有一台服务器在运行

./demo-schedule-quartz-group/src/main/java/com/ljq/demo/springboot/quartz/group/job/UserJob.java

package com.ljq.demo.springboot.quartz.group.job;

import com.ljq.demo.springboot.quartz.group.service.UserService;
import lombok.extern.slf4j.Slf4j;
import org.quartz.DisallowConcurrentExecution;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.quartz.QuartzJobBean;

import java.util.concurrent.atomic.AtomicInteger;

/**
 * @Description: 用户模块工作负载
 * @Author: junqiang.lu
 * @Date: 2020/11/14
 */
@Slf4j
@DisallowConcurrentExecution
public class UserJob extends QuartzJobBean {

    @Autowired
    private UserService userService;

    private final AtomicInteger counts = new AtomicInteger();

    @Override
    protected void executeInternal(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        log.debug("【定时任务】第【{}】次执行，用户总数:{}", counts.incrementAndGet(), userService.countAll());
    }
}

./demo-schedule-quartz-group/src/main/java/com/ljq/demo/springboot/quartz/group/job/UserJob2.java

package com.ljq.demo.springboot.quartz.group.job;

import lombok.extern.slf4j.Slf4j;
import org.quartz.DisallowConcurrentExecution;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.scheduling.quartz.QuartzJobBean;

/**
 * @Description: 用户工作负载2
 * @Author: junqiang.lu
 * @Date: 2020/11/14
 */
@Slf4j
@DisallowConcurrentExecution
public class UserJob2 extends QuartzJobBean {
    @Override
    protected void executeInternal(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        log.debug("------定时任务开始执行-------");
    }
}

​

3.2.3 定时任务配置类

与单机模式一致

./demo-schedule-quartz-group/src/main/java/com/ljq/demo/springboot/quartz/group/common/config/QuartzScheduleConfig.java

​

3.2.4 application.yml 配置文件

这里配置两个数据源，是为了将 Quartz 数据源和业务的数据源区分开， Quartz 使用独立的数据源效率更高

./demo-schedule-quartz-group/src/main/resources/application.yml

## config

## server
server:
  port: 8551

## spring config
spring:
  datasource:
    user:
      url: "jdbc:mysql://172.16.140.10:3306/demo?useUnicode=true&characterEncoding=utf8\
            &useJDBCCompliantTimezoneShift=true&useLegacyDatetimeCode=false&serverTimezone=GMT%2b8\
            &useSSL=true&allowMultiQueries=true&autoReconnect=true&nullCatalogMeansCurrent=true\
            &nullCatalogMeansCurrent=true"
      username: root
      password: "Qwert12345!"
      driver-class-name: com.mysql.cj.jdbc.Driver

    quartz:
      url: "jdbc:mysql://172.16.140.10:3306/schedule_quartz?useUnicode=true&characterEncoding=utf8\
            &useJDBCCompliantTimezoneShift=true&useLegacyDatetimeCode=false&serverTimezone=GMT%2b8\
            &useSSL=true&allowMultiQueries=true&autoReconnect=true&nullCatalogMeansCurrent=true\
            &nullCatalogMeansCurrent=true"
      username: root
      password: "Qwert12345!"
      driver-class-name: com.mysql.cj.jdbc.Driver
  quartz:
    scheduler-name: userSchedule
    job-store-type: jdbc
    auto-startup: true
    startup-delay: 1s
    wait-for-jobs-to-complete-on-shutdown: true
    overwrite-existing-jobs: false
    jdbc:
      initialize-schema: never
    properties:
      org:
        quartz:
          jobStore:
            dataSource: quartzDataSource
            class: org.quartz.impl.jdbcjobstore.JobStoreTX
            driverDelegateClass: org.quartz.impl.jdbcjobstore.StdJDBCDelegate
            tablePrefix: QRTZ_
            isClustered: true
            clusterCheckinInterval: 1000
            useProperties: false
          threadPool:
            threadCount: 25
            threadPriority: 5
            class: org.quartz.simpl.SimpleThreadPool

​

3.2.5 数据源配置类
./demo-schedule-quartz-group/src/main/java/com/ljq/demo/springboot/quartz/group/common/config/DataSourceConfig.java

package com.ljq.demo.springboot.quartz.group.common.config;

import com.zaxxer.hikari.HikariDataSource;
import org.springframework.boot.autoconfigure.jdbc.DataSourceProperties;
import org.springframework.boot.autoconfigure.quartz.QuartzDataSource;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.util.StringUtils;

import javax.sql.DataSource;

/**
 * @Description: 数据源配置
 * @Author: junqiang.lu
 * @Date: 2020/11/17
 */
@Configuration
public class DataSourceConfig {

    /**
     * 用户数据源配置(主数据源)
     *
     * @return
     */
    @Primary
    @Bean("userDatasourceProperties")
    @ConfigurationProperties(prefix = "spring.datasource.user")
    public DataSourceProperties userDataSourceProperties() {
        return new DataSourceProperties();
    }

    /**
     * 用户数据源(主数据源)
     *
     * @return
     */
    @Primary
    @Bean("userDataSource")
    @ConfigurationProperties(prefix = "spring.datasource.user.hikari")
    public DataSource userDataSource() {
        DataSourceProperties properties = this.userDataSourceProperties();
        return createHikariDataSource(properties);
    }

    /**
     * Quartz 数据源配置
     *
     * @return
     */
    @Bean("quartzDataSourceProperties")
    @ConfigurationProperties(prefix = "spring.datasource.quartz")
    public DataSourceProperties quartzDataSourceProperties() {
        return new DataSourceProperties();
    }

    /**
     * Quartz 数据源
     *
     * @return
     */
    @Bean("quartzDataSource")
    @ConfigurationProperties(prefix = "spring.datasource.quartz.hikari")
    @QuartzDataSource
    public DataSource quartzDataSource() {
        DataSourceProperties properties = this.quartzDataSourceProperties();
        return createHikariDataSource(properties);
    }

    /**
     * 创建 Hikari 数据库连接池
     *
     * @param properties
     * @return
     */
    private HikariDataSource createHikariDataSource(DataSourceProperties properties) {
        HikariDataSource dataSource = properties.initializeDataSourceBuilder()
                .type(HikariDataSource.class)
                .build();
        if (StringUtils.hasText(properties.getName())) {
            dataSource.setPoolName(properties.getName());
        }
        return dataSource;
    }

}

@Primary 表名数据源为主数据源

@QuartzDataSource 指明该数据源为 Quartz 框架的数据源

​

3.2.6 SpringBoot 启动类

这里为了模拟集群工作环境，写两个 SpringBoot 启动类,端口号区分开

./demo-schedule-quartz-group/src/main/java/com/ljq/demo/springboot/quartz/group/DemoScheduleQuartzGroupApplication.java

package com.ljq.demo.springboot.quartz.group;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * @author apple
 */
@SpringBootApplication
public class DemoScheduleQuartzGroupApplication {

    public static void main(String[] args) {
        SpringApplication.run(DemoScheduleQuartzGroupApplication.class, args);
    }

}

./demo-schedule-quartz-group/src/main/java/com/ljq/demo/springboot/quartz/group/DemoScheduleQuartzGroupApplication2.java

package com.ljq.demo.springboot.quartz.group;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * @Description: Quartz 定时任务集群模式应用启动类2
 * @Author: junqiang.lu
 * @Date: 2020/11/18
 */
@SpringBootApplication
public class DemoScheduleQuartzGroupApplication2 {

    public static void main(String[] args) {
        System.setProperty("server.port", "8552");
        SpringApplication.run(DemoScheduleQuartzGroupApplication2.class);
    }
}

依次将启动这两个程序，即可实现集群工作的效果，观察两个控制台的输出日志，会发现两边都会有日志输出，但是在同一时间只有一个定时任务在运行

3.2.7 手动创建定时任务

直接启动 SpringBoot 项目，程序会自动创建定时任务，但定时任务也可以通过手动的方式创建，可以选择是否覆盖已有任务

测试类

./demo-schedule-quartz-group/src/test/java/com/ljq/demo/springboot/quartz/group/common/config/QuartzScheduleConfigTest.java

package com.ljq.demo.springboot.quartz.group.common.config;

import com.ljq.demo.springboot.quartz.group.DemoScheduleQuartzGroupApplication;
import com.ljq.demo.springboot.quartz.group.job.UserJob;
import com.ljq.demo.springboot.quartz.group.job.UserJob2;
import org.junit.jupiter.api.Test;
import org.mockito.internal.util.collections.Sets;
import org.quartz.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

/**
 * 定时任务配置测试类
 */
@SpringBootTest(classes = DemoScheduleQuartzGroupApplication.class)
class QuartzScheduleConfigTest {


    @Autowired
    private Scheduler scheduler;

    private static final String USER_JOB_DETAIL_NAME = "userJob001";
    private static final String USER_JOB_TRIGGER_NAME = "userJobTrigger001";

    private static final String USER_JOB_2_DETAIL_NAME = "userJob002";
    private static final String USER_JOB_2_TRIGGER_NAME = "userJob2Trigger002";

    private static final String USER_JOB_2_CRON = "0/10 * * * * ? *";

    /**
     * 手动添加用户定时任务配置
     *
     * @throws SchedulerException
     */
    @Test
    public void addUserJobConfig() throws SchedulerException {
        // 创建 JobDetail
        JobDetail jobDetail = JobBuilder.newJob(UserJob.class)
                .withIdentity(USER_JOB_DETAIL_NAME)
                .storeDurably()
                .build();
        // 创建 Trigger
        SimpleScheduleBuilder scheduleBuilder = SimpleScheduleBuilder.simpleSchedule()
                .withIntervalInSeconds(5)
                .repeatForever();
        Trigger trigger = TriggerBuilder.newTrigger()
                .forJob(jobDetail)
                .withIdentity(USER_JOB_TRIGGER_NAME)
                .withSchedule(scheduleBuilder)
                .build();
        // 添加调度任务
        // 不覆盖已有任务
//        scheduler.scheduleJob(jobDetail, trigger);

        // 覆盖已有任务
        scheduler.scheduleJob(jobDetail, Sets.newSet(trigger), true);
    }


    /**
     * 手动创建用户2定时任务
     *
     * @throws SchedulerException
     */
    @Test
    public void addUserJob2Config() throws SchedulerException {
        // 创建 JobDetail
        JobDetail jobDetail = JobBuilder.newJob(UserJob2.class)
                .withIdentity(USER_JOB_2_DETAIL_NAME)
                .storeDurably()
                .build();
        // 创建 Trigger
        CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(USER_JOB_2_CRON);
        Trigger trigger = TriggerBuilder.newTrigger()
                .forJob(jobDetail)
                .withIdentity(USER_JOB_2_TRIGGER_NAME)
                .withSchedule(scheduleBuilder)
                .build();
        // 添加调度任务
        // 不覆盖已有任务
//        scheduler.scheduleJob(jobDetail, trigger);
        // 覆盖已有任务
        scheduler.scheduleJob(jobDetail, Sets.newSet(trigger), true);

    }

}

无论是手动创建还是自动创建，效果是一样的

​

4 推荐参考资料

Quartz 官方: http://www.quartz-scheduler.org/documentation/2.4.0-SNAPSHOT/index.html

Spring Job？Quartz？XXL-Job

​

5 Github 源码

Gtihub 源码地址 : https://github.com/Flying9001/springBootDemo

个人公众号:404Code,分享半个互联网人的技术与思考，感兴趣的可以关注.
404Code

Flying9001
关注
专栏目录
SpringBoot 整合Quartz（集群）实现定时任务调度
qq_33914912的博客
02-14 2862
如果对quartz集群原理和配置不太了解，大家可参考文章：Quartz集群原理及配置应用，这里我就不细说了 SpringBoot实现定时任务两种方式： 1、基于 spring的@Scheduled注解; 可参考文章：SpringBoot整合Quartz定时任务（基于注解方式），这种方式比较便捷，在单台服务部署情况下可使用，若部署多台机器，到了时间点，便会同时均开始这个执行定时任务（问题）。 ...
一、Quartz任务调度--单机
清晨
03-28 1749
Quartz是一个纯Java 实现的作业调度工具，相当于数据库中的Job、Windows 的计划任务、Unix/Linux 下的Cron，但Quartz 可以把排程控制的更精细。 可用于邮件提醒和告警。 1.简单使用 1.引入quartz jar包 --> quartz quartz 1.5.2 2.//普通java类 public class UserQueryTask
调度框架-Quartz-单机Quartz使用以及Job持久化
最新发布
weixin_51918722的博客
07-31 461
Quzrtz的Job持久化到MySQL, 并实现Job增删改查, 单次调用Job
spring boot quartz 使用 单机模式 多任务
july_young的博客
12-03 971
pom文件依赖： &lt;dependency&gt; &lt;groupId&gt;org.quartz-scheduler&lt;/groupId&gt; &lt;artifactId&gt;quartz&lt;/artifactId&gt; &lt;version&gt;2.2.1&lt;/version&gt; &lt;/dependency&amp
SpringBoot整合Quartz实现定时任务
pan_junbiao的博客
11-08 3万+
1、Quartz简介 Quartz是OpenSymphony开源组织在Job scheduling领域又一个开源项目，它可以与J2EE与J2SE应用程序相结合也可以单独使用。Quartz可以用来创建简单或为运行十个，百个，甚至是好几万个Jobs这样复杂的程序。Jobs可以做成标准的Java组件或 EJBs。 1.1 Quartz的三大核心组件 调度器：Scheduler。 任务：JobDetail。 触发器：Trigger，包括 SimpleTrigger 和 CronTrigger。 （1）Jo
超级全面Quartz单机版本定时器
qq_40053836的博客
07-13 526
今天带来一个基于SpringBoot2.x整合Quartz定时器，也相当于给自己做个笔记。 项目优点：灵活插拔，接口编程，功能全面，MVC模式，方便管理 Quartz简介： Quartz是OpenSymphony开源组织在Job scheduling领域又一个开源项目，它可以与J2EE与J2SE应用程序相结合也可以单独使用。Quartz可以用来创建简单或为运行十个，百个，甚至是好几万个Jobs这样...
！！！超简单 springboot2.0中 单机 quartz yml文件配置 持久化到数据库 看完不会你打我
le185186826的博客
06-21 6349
创建表 添加引用 &amp;amp;lt;!--quartz--&amp;amp;gt; &amp;amp;lt;dependency&amp;amp;gt; &amp;amp;lt;groupId&amp;amp;gt;org.springframework.boot&amp;amp;lt;/groupId&amp;amp;gt; &amp;amp;lt;a
Spring Boot与Quartz集成实现分布式定时任务集群
AlanGogogo
02-08 8213
直接贴代码POM<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.0 http://maven.apache.org/xsd/ma
Spring boot实现定时任务一：集成Quartz
12程序猿的博客
08-05 331
Spring boot集成Quartz实现定时任务 目录1.Quartz介绍1.1 Quartz的三大核心组件1.2 CronTrigger配置格式2.Springboot 整合Quartz框架2.1 创建项目2.2 实现定时任务3.代码示例 1.Quartz介绍 Quartz 是一个功能丰富的开源作业调度库，它由 Java 写成，可以集成在任何 Java 应用程序中，包括 Java SE 和 Java EE 等。 使用 Quartz 可以创建简单或者复杂的执行计划，它支持数据库、集群、插件以及邮件
spring-boot 定时任务集群
07-01
本篇文章将深入探讨如何在Spring Boot 2.1.6版本中配置和管理定时任务，并实现任务的集群部署以及任务的持久化存储到MySQL数据库。 **一、Spring Boot定时任务** 1. **@Scheduled注解**：Spring Boot提供了对定时...
spring-boot集成quartz实现动态任务管理，支持集群
01-15
通过以上步骤，你就可以在Spring Boot应用中成功集成Quartz，实现动态任务管理和集群支持。在实际业务场景中，你可以根据需求创建更多的Job和Trigger，或者自定义JobDataMap来传递参数。务必注意，对于大型、复杂的...
spring-boot-starter-quartz：Quartz-Scheduler的Spring-Boot自动配置
01-31
Quartz Scheduler的Spring-Boot自动配置 只是Quartz Scheduler的Spring-Boot启动器。 当然，Quartz Scheduler已经有好几个启动器，但是它们都不能满足我的所有需求，因此我创建了自己的启动器。 这只是一个业余项目。 使用此工具（尤其是在生产系统中）的风险自负。 内容 需求，依赖 弹簧靴 石英调度器 经过Spring Boot测试 （直到1.0.2）1.3.8、1.4.6、1.5.3、1.5.6， （自1.0.3起）1.4.6、1.5.10、1.5.16、1.5.17 用法 < dependency> < groupId>de.chandre.quartz</ groupId> < artifactId>spring-boot-starter-quartz</ artifactId> < version>1.0.5</ version> </ dependency> 也许您必须显式启用软件包的组件扫描： @SpringBootApplication @EnableAutoConfiguratio
springboot2.3集成quartz定时任务持久化数据库,支持集群
07-13
在本文中，我们将深入探讨如何在Spring Boot 2.3版本中集成Quartz定时任务，并实现其持久化到数据库，以便支持集群环境。这个过程的关键在于配置Quartz Scheduler，设置数据库连接，以及确保任务在多节点环境中能够...
玩转 Spring Boot 集成篇（定时任务框架Quartz）
一猿小讲
02-13 6853
在日常项目研发中，定时任务可谓是必不可少的一环，关于 Spring Boot 如何实现静态定时任务、动态定时任务以及如何开启多线程跑任务，均已在上篇分享过，不再赘述。虽然 Spring B...
【SpringBoot】82、SpringBoot集成Quartz实现动态管理定时任务
热门推荐
Asurplus
06-29 3万+
Quartz 是一个开源的作业调度框架，它完全由 Java 写成，并设计用于 J2SE 和 J2EE 应用中。它提供了巨大的灵 活性而不牺牲简单性。你能够用它来为执行一个作业而创建简单的或复杂的调度。它有很多特征，如：数据库支持，集群，插件，EJB 作业预构 建，JavaMail 及其它，支持 cron-like 表达式等等
SpingBoot+Quartrz单机版实现动态定时任务(利用反射实现自定义业务)
一恍过去
06-06 2万+
SpingBoot+Quartrz单机版实现动态定时任务(利用反射实现自定义业务)
单点quartz
日拱一卒，功不唐捐
07-15 1778
在tomcat集成quartz，实现tomcat启动后，quartz定时执行任务
spring quartz 集群模式
幽靈齋
07-05 262
本文是基于quartz-1.6.6版本 当我们用到集群模式部署项目的时候就要考虑到定时任务的集群问题， 这里有四种解决方案： 第一：自己通过代码实现（比如通过不同机器的jvm参数配置或者自己建立任务表去控制执行） 第二：确保一台机器启动quartz 第三：将quartz单独抽取部署单实例 第四：用quartz自身提供的解决方案 本文采用方案四。 quartz集群各节点之...
Spring boot定时器单机版（单线程）
SELECT_BIN的博客
08-31 534
一、Spring定时器 搭框架的不再赘述，吉特哈贝上很多滴； 在Spring Boot中实现定时任务功能，可以通过Spring自带的定时任务调度，也可以通过集成经典开源组件Quartz实现任务调度。 1、cron表达式方式（适用于重复性的执行，类似于定时器） 使用自带的定时任务，非常简单，只需要像下面这样，加上注解就好，不需要像普通定时任务框架那样继承任何定时处理接口 ，简单示例代码如下：...
spring boot + quartz 集群
06-09
Spring Boot和Quartz可以很好地结合使用来实现定时任务的调度。而在集群环境下，需要特别注意一些细节。 首先，要确保Quartz的JobStore使用的是数据库存储，而不是内存存储。这样才能保证多个节点之间的任务信息同步。其次，需要配置JobStore的表前缀以避免不同节点之间的表名冲突。 其次，在集群环境下，需要使用一个中心化的调度节点来协调任务的执行。这个节点可以是其中的一个节点，也可以是专门的一个节点。其他节点只需要配置为从中心节点获取任务并执行即可。这个可以通过配置JobStore的isClustered属性为true来实现。 最后，需要注意的是，集群环境下任务的执行情况需要集中收集和监控。可以使用Quartz提供的JobListener和TriggerListener来实现这个功能。另外，可以考虑使用分布式任务调度平台来更方便地管理和监控任务的执行情况。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值