Spring boot 集成Quartz 实现定时任务动态管理服务端

最新推荐文章于 2023-09-06 08:00:00 发布
最新推荐文章于 2023-09-06 08:00:00 发布
阅读量869 收藏 3
点赞数 1
分类专栏： 后端 文章标签： Spring boot Quartz 多数据源 动态管理定时任务
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/macau2008/article/details/79883171
版权

调查了下用Spring boot集成Quartz来实现定时任务的动态管理，记下来备用。

主要使用 Spring boot、Quartz、Mybatis实现，其中Quartz任务在SqlServer数据库保存，业务数据库是Oracle。

需要实现数据源的动态管理，定时任务使用Spring IOC管理等功能。

创建Maven project

POM中依赖如下：

<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.10.RELEASE</version>
</parent>
<properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <spring.boot.version>1.5.10.RELEASE</spring.boot.version>
        <spring.cloud.version>Edgware.SR2</spring.cloud.version>
        <java.version>1.8</java.version>
</properties> 
<dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <exclusions>
                <exclusion>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-starter-logging</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <!-- Spring Boot Test 依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!-- GSON -->
        <dependency>
            <groupId>com.google.code.gson</groupId>
            <artifactId>gson</artifactId>
        </dependency>
        <!-- 代码简化 -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <!-- 日志 Log4j2 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-log4j2</artifactId>
        </dependency>
        <!-- Log4j2 异步支持 -->
        <dependency>
            <groupId>com.lmax</groupId>
            <artifactId>disruptor</artifactId>
            <version>3.3.6</version>
        </dependency>
        <!-- 使用 @ConfigurationProperties @Value 使用 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>        
        <!-- quartz -->
        <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>
            <version>2.2.1</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
        </dependency>
        <!-- mybatis -->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.3.1</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/com.github.pagehelper/pagehelper-spring-boot-starter -->
        <dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper-spring-boot-starter</artifactId>
            <version>1.2.3</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/com.alibaba/druid -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.8</version>
        </dependency>
        <!--ojdbc -->
        <dependency>
            <groupId>com.oracle</groupId>
            <artifactId>ojdbc6</artifactId>
            <version>11.2.0</version>
        </dependency>
        <!-- sqlserver -->
        <dependency>
            <groupId>com.microsoft.sqlserver</groupId>
            <artifactId>sqljdbc4</artifactId>
            <version>4.0</version>
        </dependency>
        <!-- api document -->
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger2</artifactId>
            <version>2.2.2</version>
        </dependency>
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger-ui</artifactId>
            <version>2.2.2</version>
        </dependency>
        <!--junit -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
    <build>
        <pluginManagement>
            <plugins>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <configuration>
                        <source>${java.version}</source>
                        <target>${java.version}</target>
                        <skip>true</skip>
                        <encoding>${project.build.sourceEncoding}</encoding>
                    </configuration>
                </plugin>
                <!-- 忽略Test包 -->
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-surefire-plugin</artifactId>
                    <configuration>
                        <skipTests>true</skipTests>
                    </configuration>
                </plugin>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                    <configuration>
                        <mainClass>com.demo.service.job.JobManagerApplication</mainClass>
                    </configuration>
                    <executions>
                        <execution>
                            <goals>
                                <goal>repackage</goal>
                            </goals>
                        </execution>
                    </executions>
                </plugin>
            </plugins>
        </pluginManagement>
    </build>

上面需要注意的是ojdbc的jar需要手动安装到本地maven仓库。

配置Quartz
在SqlServer中创建Quartz需要的数据库和表，这里的建表语句可以自行到Quartz官网下载；
在src/main/resources下新建quartz.properties文件用来配置Quartz：
org.quartz.scheduler.instanceName = DefaultQuartzScheduler
org.quartz.scheduler.rmi.export = false
org.quartz.scheduler.rmi.proxy = false
org.quartz.scheduler.wrapJobExecutionInUserTransaction = false
# 线程池配置
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.class = org.quartz.impl.jdbcjobstore.JobStoreTX
org.quartz.jobStore.tablePrefix = QRTZ_
org.quartz.jobStore.dataSource = qzDS
org.quartz.jobStore.misfireThreshold = 5000
org.quartz.dataSource.qzDS.driver =  com.microsoft.sqlserver.jdbc.SQLServerDriver
org.quartz.dataSource.qzDS.URL = jdbc:sqlserver://127.0.0.1;DatabaseName=QUARTZ_DB
org.quartz.dataSource.qzDS.user = 
org.quartz.dataSource.qzDS.password = 
org.quartz.dataSource.qzDS.maxConnections = 10
编写代码，使用配置文件中的配置，并且把定时任务交给Spring IOC处理

自定义任务工厂类，将定时任务交给Spring

@Component
public class QuartzJobFactory extends AdaptableJobFactory {
    @Autowired
    private AutowireCapableBeanFactory autowireCapableBeanFactory;

    /**
     * @see org.springframework.scheduling.quartz.AdaptableJobFactory#createJobInstance(org.quartz.spi.TriggerFiredBundle)
     */
    @Override
    protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception {
        Object jobInstance = super.createJobInstance(bundle);
        // 实现Job的IOC管理
        autowireCapableBeanFactory.autowireBean(jobInstance);
        return jobInstance;
    }
}

配置定时任务调度器

@Configuration
public class SchedulerConfig {
    @Autowired
    private QuartzJobFactory jobFactory;

    /**
     * 定时任务初始化监听器
     * 
     * @Title: initListener
     */
    @Bean
    public QuartzInitializerListener initListener() {
        return new QuartzInitializerListener();
    }

    /**
     * 任务调度器
     * 
     * @Title: scheduler
     * @throws IOException
     */
    @Bean(name = "Scheduler")
    public Scheduler scheduler() throws IOException {
        return schedulerFactoryBean().getScheduler();
    }

    /**
     * 任务调度器工厂
     * 
     * @Title: schedulerFactoryBean
     * @throws IOException
     */
    @Bean(name = "SchedulerFactory")
    public SchedulerFactoryBean schedulerFactoryBean() throws IOException {
        SchedulerFactoryBean factory = new SchedulerFactoryBean();
        factory.setQuartzProperties(quartzProperties());
        factory.setOverwriteExistingJobs(true);
        factory.setStartupDelay(15);
        factory.setJobFactory(jobFactory);
        return factory;
    }

    /**
     * 读取定时任务配置
     * 
     * @Title: quartzProperties
     * @throws IOException
     */
    @Bean
    public Properties quartzProperties() throws IOException {
        PropertiesFactoryBean propertiesFactoryBean = new PropertiesFactoryBean();
        propertiesFactoryBean.setLocation(new ClassPathResource("/quartz.properties"));
        propertiesFactoryBean.afterPropertiesSet();
        return propertiesFactoryBean.getObject();
    }
}
配置多数据源
定义application.properties
server.port = 8001
spring.application.name =job-manager
#business data source#
biz.datasource.type = com.alibaba.druid.pool.DruidDataSource
biz.datasource.url = jdbc:oracle:thin:@127.0.0.1:1521:orcl
biz.datasource.driver-class-name = oracle.jdbc.OracleDriver
biz.datasource.username = 
biz.datasource.password = 
#job data sources#
job.datasource.type = com.alibaba.druid.pool.DruidDataSource
job.datasource.url = jdbc:sqlserver://127.0.0.1;DatabaseName=QUARTZ_DB
job.datasource.driver-class-name = com.microsoft.sqlserver.jdbc.SQLServerDriver
job.datasource.username = 
job.datasource.password = 
#druid#
spring.druid.initialSize = 10
spring.druid.minIdle = 10
spring.druid.maxActive = 20
spring.druid.maxWait = 60000
spring.druid.maxOpenPreparedStatements = 50
spring.druid.validationQuery = select count(0) from dual
spring.druid.testWhileIdle = true
#Mybatis#
mybatis.mapper-locations = classpath:mapper/mybatis-sqlmap-*.xml
mybatis.type-aliases-package = com.demo.service.job.entity
#PageHelper#
pagehelper.autoDialect = true
pagehelper.closeConn = true
pagehelper.offset-as-page-num = false
使用Aspect实现动态切换数据源

创建数据源名称枚举

public enum DataSourceNameEnum {
        /** 业务库 */
        BUSINESS("biz"),
        /** 定时任务库 */
        QUARTZ_JOB("job");
    /** 数据源名称 */
    private String name;

    /**
     * 
     * 构造函数
     * 
     * @param name
     */
    private DataSourceNameEnum(String name) {
        this.name = name;
    }

    /**
     * 获取：数据源名称
     */
    public String getName() {
        return name;
    }
}

自定义数据源注解

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface DataSourceAnnotation {
    /** 默认使用业务数据库 */
    DataSourceNameEnum value() default DataSourceNameEnum.BUSINESS;
}

数据源上下文管理器

public class DataSourceContextHolder {
    final static ThreadLocal<String> local = new ThreadLocal<>();

    public static void setDataSourceName(String name) {
        local.set(name);
    }

    public static String getDataSourceName() {
        return local.get();
    }
}

实现动态数据源

@Log4j2
public class DynamicDataSource extends AbstractRoutingDataSource {

    /**
     * @see org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource#determineCurrentLookupKey()
     */
    @Override
    protected Object determineCurrentLookupKey() {
        String dataSourceName = DataSourceContextHolder.getDataSourceName();
        log.debug("Current data source name is {}.", dataSourceName);
        return dataSourceName;
    }
}

数据源配置管理

@Configuration
public class DataSourceConfig {
    @Bean(name = "biz")
    @ConfigurationProperties(prefix = "biz.datasource")
    public DataSource bizDataSource() {
        return DataSourceBuilder.create().build();
    }

    @Bean(name = "job")
    @ConfigurationProperties(prefix = "job.datasource")
    public DataSource jobDataSource() {
        return DataSourceBuilder.create().build();
    }

    @Bean(name = "dataSource")
    @Primary
    public DataSource dataSource() {
        DynamicDataSource dynamicDataSource = new DynamicDataSource();
        DataSource biz = bizDataSource();
        DataSource job = jobDataSource();
        dynamicDataSource.setDefaultTargetDataSource(biz);
        Map<Object, Object> targetDataSources = new HashMap<>();
        targetDataSources.put(DataSourceNameEnum.BUSINESS.getName(), biz);
        targetDataSources.put(DataSourceNameEnum.QUARTZ_JOB.getName(), job);
        dynamicDataSource.setTargetDataSources(targetDataSources);
        return dynamicDataSource;
    }
}

使用AOP实现数据源切换

@Aspect
@Order(1)
@Component
@Log4j2
public class DataSourceAspect {
    @Pointcut("execution(* com.demo.service.job.service.impl.*Impl.*(..))")
    public void aspect() {}

    @Before("aspect()")
    private void before(JoinPoint point) {
        Object target = point.getTarget();
        String methodName = point.getSignature().getName();
        Class<?> clazz = target.getClass();
        Class<?>[] parameterTypes = ((MethodSignature) point.getSignature()).getMethod().getParameterTypes();

        Method method = null;
        try {
            method = clazz.getMethod(methodName, parameterTypes);
        } catch (Exception e) {
            log.error("Get {}.{} ERROR", clazz.getName(), methodName);
        }
        if (null != method && method.isAnnotationPresent(DataSourceAnnotation.class)) {
            DataSourceAnnotation dataSource = method.getAnnotation(DataSourceAnnotation.class);
            String name = dataSource.value().getName();
            DataSourceContextHolder.setDataSourceName(name);
            log.debug("Switch Data Source To {}.", name);
        }
    }
}

最重要的是，关闭Spring boot自动数据源配置

// 禁用数据源自动配置
@SpringBootApplication(exclude = { DataSourceAutoConfiguration.class })
// 事务处理在数据源切换完成后
@EnableTransactionManagement(order = 2)
public class JobManagerApplication {
    public static void main(String[] args) {
        SpringApplication.run(JobManagerApplication.class, args);
    }
}
定时任务动态管理的实现

自定义定时任务接口

public interface BaseQuartzJob extends Job {
    void execute(JobExecutionContext executionContext) throws JobExecutionException;
}

自定义任务

@Log4j2
public class PrintJob implements BaseQuartzJob {
    @Override
    public void execute(JobExecutionContext executionContext) throws JobExecutionException {
        log.info("execute printjob now");
    }
}
@Log4j2
public class FyAssetJob implements BaseQuartzJob {
    @Autowired
    private TAssetFyLmsRunLogService assetFyLmsRunLogService;

    @Override
    public void execute(JobExecutionContext executionContext) throws JobExecutionException {
        log.info("=== check run log begin===");
        TAssetFyLmsRunLogPageParam param = new TAssetFyLmsRunLogPageParam();
        param.setPageNum(1);
        param.setPageSize(12);
        List<TAssetFyLmsRunLog> list = assetFyLmsRunLogService.getAll(param);
        if (null != list && !list.isEmpty()) {
            for (TAssetFyLmsRunLog item : list) {
                log.debug(item.toString());
            }
        }
        log.info("=== check run log end===");
    }
}

其中，第二个任务，使用了Spring IOC的Bean。

定时任务管理

@Log4j2
@RestController
public class QuartzJobController {
    @Autowired
    @Qualifier("Scheduler")
    private Scheduler scheduler;

    @Autowired
    private QuartzJobInfoService quartzJobInfoService;

    /**
     * 分页检索
     * 
     * @Title: list
     */
    @ApiOperation(value = "分页检索",
        notes = "")
    @RequestMapping(value = "/list",
        method = RequestMethod.POST)
    public ResponseEntity<BaseResponse<BasePageResult<QuartzJobInfo>>> list(
        @RequestBody BaseRequest<QuartzJobPageParam> req) {
        BaseResponse<BasePageResult<QuartzJobInfo>> response = new BaseResponse<>();
        BasePageResult<QuartzJobInfo> result = quartzJobInfoService.list(req);
        response.setResult(result);
        return new ResponseEntity<BaseResponse<BasePageResult<QuartzJobInfo>>>(response, HttpStatus.OK);
    }

    /**
     * 新增任务
     * 
     * @Title: add
     */
    @ApiOperation(value = "新增任务",
        notes = "")
    @RequestMapping(value = "/add",
        method = RequestMethod.POST)
    public ResponseEntity<BaseResponse<String>> add(@RequestBody BaseRequest<QuarzJobParam> req) {
        BaseResponse<String> response = new BaseResponse<>();
        String code = ResultCodeEnum.SUCCESS.getCode();
        String result = "新增定时任务成功！";

        // get parameter fro request
        QuarzJobParam item = req.getParam();
        String jobClassName = item.getJobClassName();
        String jobGroupName = item.getJobGroup();
        String cronExpression = item.getCornExpression();

        try {
            // build jobDetail and trigger
            JobDetail jobDetail = JobBuilder.newJob(getClass(jobClassName).getClass())
                .withIdentity(jobClassName, jobGroupName).build();
            // 表达式调度构建器(即任务执行的时间)
            CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(cronExpression);
            // 按新的cronExpression表达式构建一个新的trigger
            CronTrigger trigger = TriggerBuilder.newTrigger().withIdentity(jobClassName, jobGroupName)
                .withSchedule(scheduleBuilder).build();
            // 执行调度
            scheduler.start();
            scheduler.scheduleJob(jobDetail, trigger);
        } catch (SchedulerException e) {
            code = ResultCodeEnum.ERROR.getCode();
            result = "调度定时任务失败！";
            log.error("调度定时任务失败：{}", e.getMessage());
        } catch (Exception e) {
            code = ResultCodeEnum.ERROR.getCode();
            result = "构建定时任务失败！";
            log.error("构建定时任务失败：{}", e.getMessage());
        }

        response.setCode(code);
        response.setResult(result);
        return new ResponseEntity<BaseResponse<String>>(response, HttpStatus.OK);
    }

    /**
     * 暂停任务
     * 
     * @Title: pause
     */
    @ApiOperation(value = "暂停任务",
        notes = "")
    @RequestMapping(value = "/pause",
        method = RequestMethod.POST)
    public ResponseEntity<BaseResponse<String>> pause(@RequestBody BaseRequest<QuarzJobParam> req) {
        BaseResponse<String> response = new BaseResponse<>();
        String code = ResultCodeEnum.SUCCESS.getCode();
        String result = "暂停定时任务成功！";

        // get parameter fro request
        QuarzJobParam item = req.getParam();
        String jobClassName = item.getJobClassName();
        String jobGroupName = item.getJobGroup();

        try {
            scheduler.pauseJob(JobKey.jobKey(jobClassName, jobGroupName));
        } catch (SchedulerException e) {
            code = ResultCodeEnum.ERROR.getCode();
            result = "暂停定时任务失败！";
            log.error("暂停定时任务失败：{}", e.getMessage());
        }

        response.setCode(code);
        response.setResult(result);
        return new ResponseEntity<BaseResponse<String>>(response, HttpStatus.OK);
    }

    /**
     * 恢复任务
     * 
     * @Title: resume
     */
    @ApiOperation(value = "恢复任务",
        notes = "")
    @RequestMapping(value = "/resume",
        method = RequestMethod.POST)
    public ResponseEntity<BaseResponse<String>> resume(@RequestBody BaseRequest<QuarzJobParam> req) {
        BaseResponse<String> response = new BaseResponse<>();
        String code = ResultCodeEnum.SUCCESS.getCode();
        String result = "恢复定时任务成功！";

        // get parameter fro request
        QuarzJobParam item = req.getParam();
        String jobClassName = item.getJobClassName();
        String jobGroupName = item.getJobGroup();

        try {
            scheduler.resumeJob(JobKey.jobKey(jobClassName, jobGroupName));
        } catch (SchedulerException e) {
            code = ResultCodeEnum.ERROR.getCode();
            result = "恢复定时任务失败！";
            log.error("恢复定时任务失败：{}", e.getMessage());
        }

        response.setCode(code);
        response.setResult(result);
        return new ResponseEntity<BaseResponse<String>>(response, HttpStatus.OK);
    }

    /**
     * 删除任务
     * 
     * @Title: remove
     */
    @ApiOperation(value = "删除任务",
        notes = "")
    @RequestMapping(value = "/remove",
        method = RequestMethod.POST)
    public ResponseEntity<BaseResponse<String>> remove(@RequestBody BaseRequest<QuarzJobParam> req) {
        BaseResponse<String> response = new BaseResponse<>();
        String code = ResultCodeEnum.SUCCESS.getCode();
        String result = "删除定时任务成功！";

        // get parameter fro request
        QuarzJobParam item = req.getParam();
        String jobClassName = item.getJobClassName();
        String jobGroupName = item.getJobGroup();

        try {
            scheduler.pauseTrigger(TriggerKey.triggerKey(jobClassName, jobGroupName));
            scheduler.unscheduleJob(TriggerKey.triggerKey(jobClassName, jobGroupName));
            scheduler.deleteJob(JobKey.jobKey(jobClassName, jobGroupName));
        } catch (SchedulerException e) {
            code = ResultCodeEnum.ERROR.getCode();
            result = "删除定时任务失败！";
            log.error("删除定时任务失败：{}", e.getMessage());
        }

        response.setCode(code);
        response.setResult(result);
        return new ResponseEntity<BaseResponse<String>>(response, HttpStatus.OK);
    }

    /**
     * 更新任务触发器
     * 
     * @Title: refresh
     */
    @ApiOperation(value = "更新任务",
        notes = "")
    @RequestMapping(value = "/refresh",
        method = RequestMethod.POST)
    public ResponseEntity<BaseResponse<String>> refresh(@RequestBody BaseRequest<QuarzJobParam> req) {
        BaseResponse<String> response = new BaseResponse<>();
        String code = ResultCodeEnum.SUCCESS.getCode();
        String result = "更新定时任务成功！";

        // get parameter fro request
        QuarzJobParam item = req.getParam();
        String jobClassName = item.getJobClassName();
        String jobGroupName = item.getJobGroup();
        String cronExpression = item.getCornExpression();

        try {
            TriggerKey triggerKey = TriggerKey.triggerKey(jobClassName, jobGroupName);
            // 表达式调度构建器
            CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(cronExpression);
            CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);
            // 按新的cronExpression表达式重新构建trigger
            trigger = trigger.getTriggerBuilder().withIdentity(triggerKey).withSchedule(scheduleBuilder).build();
            // 按新的trigger重新设置job执行
            scheduler.rescheduleJob(triggerKey, trigger);
        } catch (SchedulerException e) {
            code = ResultCodeEnum.ERROR.getCode();
            result = "更新定时任务失败！";
            log.error("更新定时任务失败：{}", e.getMessage());
        }

        response.setCode(code);
        response.setResult(result);
        return new ResponseEntity<BaseResponse<String>>(response, HttpStatus.OK);
    }

    /**
     * 获得任务类
     * 
     * @Title: getClass
     * @throws Exception
     */
    private static BaseQuartzJob getClass(String className) throws Exception {
        Class<?> clazz = Class.forName(className);
        return (BaseQuartzJob) clazz.newInstance();
    }
}

主要的代码已经帖完了，看一下工程架构

启动项目，使用SWAGGER查看API

可以使用swagger直接进行测试，将我们编写的两个定时任务添加到定时任务调度器中。

下图是定时任务的执行日志


码YouMe
关注
专栏目录
Spring Boot进阶(68)：如何用SpringBoot轻松实现定时任务？集成Quartz来帮你！(附源码)
**My Coding Family**
09-05 2301
Quartz是一个非常流行的开源调度框架，它提供了许多强大的功能，如定时任务调度、作业管理、任务持久化等。而SpringBoot是目前Java开发中非常流行的框架之一，其对各种开源框架集成非常方便。本篇文章将介绍如何在SpringBoot中集成Quartz，以便于更好的管理和调度定时任务。
《滚雪球学Spring Boot》教程导航帖（更新于2024.06.20）
热门推荐
**My Coding Family**
06-29 4万+
《滚雪球学Spring Boot》是由CSDN博主bug菌创作的全面Spring Boot教程。作者是全栈开发专家，在多个技术社区如CSDN、掘金、InfoQ、51CTO等担任博客专家，并拥有超过30万的全网粉丝。该教程分为入门篇和进阶篇，每篇包含详细的教学步骤，涵盖Spring Boot的基础和高级主题。
Spring 定时任务动态管理
添砖加瓦
04-28 829
Spring 定时任务动态管理 pom.xml <properties> <hutool.version>5.6.6</hutool.version> <lombok.version>1.18.20</lombok.version> <spring-boot.web.version>2.2.10.RELEASE</spring-boot.web.version> </properties> <
spring整合java quartz实现动态定时任务的前台网页配置与管理
12-29
在实际项目应用中经常会用到定时任务，可以通过quartz和spring的简单配置即可完成，但如果要改变任务的执行时间、频率，废弃任务等就需要改变配置甚至代码需要重启服务器，这里介绍一下如何通过quartz与spring的组合实现动态的改变定时任务的状态的一个实现。 该jar包提供java项目源码，数据库文件以及完整的jar包。可发布运行。 如果要多问题，私信我，我会帮助解决。
SpringBoot集成Quartz实现定时任务
业精于勤-行成于思
07-28 2287
SpringBoot集成Quartz实现定时任务 工程概述 springboot-quartz是基于SpringBoot实现的定时任务工程 实现步骤分析 引入相关依赖 &amp;lt;dependencies&amp;gt; &amp;lt;dependency&amp;gt; &amp;lt;groupId&amp;gt;org.springframework.boot&amp;lt;/groupId&am
Spring boot + quartz 实现动态管理任务
我飞故我在的专栏
06-02 6986
在实际项目应用中经常会用到定时任务，可以通过quartz和spring的简单配置即可完成，但如果要改变任务的执行时间、频率，废弃任务等就需要改变配置甚至代码需要重启服务器，这里介绍一下如何通过quartz与spring的组合实现动态的改变定时任务的状态的一个实现。 配置文件 相关jar包依赖配置 这里使用的 gradle 进行依赖管理。包含了 jpa, quartz, thymeleaf...
SpringBoot整合Quartz实现定时任务（单任务、多任务)
长流仙山拟画人
08-27 3978
前言：为了实现如：定时发送邮件，订单超时等操作需要使用到任务调度，为了节约自己封装的时间所以使用Quatrz开源项目来帮助我们实现这些繁杂的操作，Quatrz内部有自己的线程池，不需要我们去手动维护线程，而且支持cron表达式等，下面我们讲解一下使用Springboot2.x来整合Quatrz 1，先是导入依赖，少了依赖可不行 &lt;project xmlns="http://maven....
springboot整合quartz实现动态任务管理
kevin的博客
05-13 2629
一，springboot整合quartz实现动态任务管理 近期在学习quartz，自己也动手用springboot和mybatis整合了quartz，实现对任务的动态开启和暂停，恢复和终止。 自己手动封装了一个相当于工具类的方法吧，通过传入任务名，任务组，还有相关job和cron表达式就可动态获取任务调度器 //StdSchedulerFactory工厂 private static St...
Spring Boot进阶(69)：轻松实现定时任务持久化！SpringBoot集成quartz带你玩转定时任务删除、暂停、获取等操作！【附项目源码】
**My Coding Family**
09-06 3238
本篇文章主要介绍了如何使用SpringBoot整合Quartz，并将定时任务写入库中。首先，我们会给出整个项目的架构，然后详细介绍如何配置Quartz，并将定时任务写入库中。最后，我们还会提供一个测试用例，用于验证我们的定时任务是否成功运行
基于Spring Boot+Vue实现的自动化测试平台源码+数据库，支持UI自动化和接口自动化
最新发布
10-20
集成动态定时任务，支持多线程，方便配置 自动化采用服务端客户端分离：服务端维护用例，客户端执行用例 您所看到的只是自动化平台控制端，如果需要执行自动化脚本，还需要客户端代码部署到执行机，后续会更新用户...
SpringBoot 动态定时器的使用方法
08-27
主要介绍了SpringBoot 动态定时器的使用方法,非常不错，具有一定的参考借鉴借鉴价值，需要的朋友可以参考下
springboot动态配置定时任务(schedule)
06-13
springboot动态配置定时任务(schedule),可不重启项目实现开关重启任务,改变任务定时规则
Springboot2-Quartz 后台可动态配置的定时任务
02-28
SpringBoot2 与 Quartz 整合的Demo。 后台可添加、修改、移除 定时任务。 也可查看当前任务的状态 灵活的定时任务
Spring 3整合Quartz 2实现定时任务三：动态暂停 恢复 修改和删除任务
07-17
Spring 3整合Quartz 2实现定时任务三：动态暂停 恢复 修改和删除任务，原http://blog.csdn.net/phantomes/article/details/37880551博客的源码例子
Spring+websocket+quartz实现消息定时推送
qq3164069700的博客
12-12 299
websocket 实现步骤 一、环境搭建 二、完成后台的功能 websocket 简单的说，websocket是真正实现了全双工通信的服务器向客户端推的互联网技术。 全双工与单工、半双工的区别? 全双工：简单地说，就是可以同时进行信号的双向传输(A->B且B->A),是瞬时同步的。 单工、半双工：一个时间段内只有一个动作发生。 推送和拉取的区别？ 推：由服务器主动发消息给客户端,就像广播。优势在于,信息的主动性和及时性。 拉：由客户端主动请求所需要的数据。 实现消息通信
springboot整合quartz定时任务，并实现动态动态管理，实现调用service注入。
qq_43566496的博客
12-18 1904
1.创建一个boot项目 创建一个简单的boot项目，加入web，和mysql的依赖。此处不赘述。 项目结构图： ![在这里插入图片描述](https://img-blog.csdnimg.cn/20191218140228112.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly...
Springboot实现quartz定时
tonghuaxl的专栏
03-05 286
需要声明的是，本篇博客参考了springboot整合Quartz实现动态配置定时任务和spring boot整合quartz实现多个定时任务。其中的大部分代码都是参考这两篇博客中的代码。在此感谢博主！ 因为项目中需要用到比较复杂的定时，就看了下quartz。参考了上面的两篇博客，算是个demo吧。 简单理解，quartz的定时可以大致分为两部分，一种时单任务，一种是多任务。 需要引入的依赖...
[精简版]springboot动态配置定时器
YiQieFuCong的博客
02-06 526
代码地址：https://github.com/gwy572294624/schedule-demo git clone https://github.com/gwy572294624/schedule-demo springboot项目 ，执行sql后修改数据库连接地址即可运行部署测试。 动态配置定时器实现逻辑（文章开始前需要了解）程序中实现就是代码实现项目结构数据库表信息pom主要工具类该类为程序中定时器增删改查类（主类）每次触发定时器时开启的方法（动态定时器触发类）该类为开启线程执行方法类（开启线程
springboot动态定时器开发
weixin_40496191的博客
04-30 2165
文章目录一、背景二、后台功能代码展示1. 反射实现方法工具类2. 远程调用接口工具类3. 定时器线程池配置4. 定时器实体类5. 定时实际工作类6. 定时器api类7. 定时器容器初始化启动类8. 容器demo调用类三、前台cron组件功能代码展示 一、背景 需要实现springboot定时调用项目类和第三方接口，并且可以通过页面进行动态配置。这里只展示后台部分，因为前台都是表单，不做展示，核心功能都在后台。代码中存在相关的冗余参数，主要是为相关业务的拓展保留参数。 二、后台功能代码展示 原理：创建map集
spring boot+quartz实现定时任务管理
06-10
使用Spring Boot和Quartz实现定时任务管理，可以让你更方便地管理和监控你的定时任务。下面是一个使用Spring Boot、Quartz和Spring MVC实现定时任务管理的示例： 首先，在你的Spring Boot应用程序中添加Quartz和Spring MVC的依赖项： ```xml <dependency> <groupId>org.quartz-scheduler</groupId> <artifactId>quartz</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> ``` 然后，在你的Spring Boot应用程序中创建一个Quartz的调度器，并添加一个Spring MVC的Controller来管理定时任务： ```java @Configuration public class QuartzConfig { @Bean public SchedulerFactoryBean schedulerFactoryBean() { SchedulerFactoryBean schedulerFactoryBean = new SchedulerFactoryBean(); schedulerFactoryBean.setTriggers(myTaskTrigger().getObject()); return schedulerFactoryBean; } @Bean public JobDetailFactoryBean myTaskJob() { JobDetailFactoryBean jobDetailFactoryBean = new JobDetailFactoryBean(); jobDetailFactoryBean.setJobClass(MyTask.class); return jobDetailFactoryBean; } @Bean public CronTriggerFactoryBean myTaskTrigger() { CronTriggerFactoryBean cronTriggerFactoryBean = new CronTriggerFactoryBean(); cronTriggerFactoryBean.setJobDetail(myTaskJob().getObject()); cronTriggerFactoryBean.setCronExpression("0/5 * * * * ?"); // 每5秒执行一次 return cronTriggerFactoryBean; } } @RestController public class TaskController { @Autowired private Scheduler scheduler; @PostMapping("/tasks") public void addTask(@RequestBody TaskInfo taskInfo) throws SchedulerException { JobDetail jobDetail = JobBuilder.newJob(taskInfo.getJobClass()) .withIdentity(taskInfo.getJobName(), taskInfo.getJobGroup()) .build(); CronTrigger trigger = TriggerBuilder.newTrigger() .withIdentity(taskInfo.getTriggerName(), taskInfo.getTriggerGroup()) .withSchedule(CronScheduleBuilder.cronSchedule(taskInfo.getCronExpression())) .build(); scheduler.scheduleJob(jobDetail, trigger); } @DeleteMapping("/tasks/{jobName}/{jobGroup}") public void deleteTask(@PathVariable String jobName, @PathVariable String jobGroup) throws SchedulerException { JobKey jobKey = new JobKey(jobName, jobGroup); scheduler.deleteJob(jobKey); } } ``` 在上面的代码中，我们创建了一个Spring MVC的Controller来管理定时任务。我们使用了Scheduler类来添加和删除定时任务。在添加定时任务时，我们使用了TaskInfo类来封装定时任务的信息。在删除定时任务时，我们使用了jobName和jobGroup来识别定时任务。 最后，在你的定时任务类中实现Job接口，并在类上添加@DisallowConcurrentExecution注解，以确保每个任务执行时只有一个实例： ```java @Component @DisallowConcurrentExecution public class MyTask implements Job { @Override public void execute(JobExecutionContext context) throws JobExecutionException { // 定时任务执行的代码 } } ``` 以上就是使用Spring Boot、Quartz和Spring MVC实现定时任务管理的示例。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值