手撸XXL-JOB（一）——定时任务的执行

最新推荐文章于 2025-05-17 18:58:19 发布
最新推荐文章于 2025-05-17 18:58:19 发布
阅读量1.6k 收藏 17
点赞数 12
CC 4.0 BY-SA版权
分类专栏： 手撸破产版XXL-JOB 文章标签： spring boot spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_55850954/article/details/138870135

SpringBoot执行定时任务

对于定时任务的执行，SpringBoot提供了三种创建方式：
1）基于注解(@Scheduled)
2）基于接口（SchedulingConfigurer）
3）基于注解设定多线程定时任务

基于Scheduled注解

首先我们创建一个SpringBoot项目，然后引入spring-boot-starter-web依赖，在启动类上添加EnableScheduling注解开启定时任务管理。

package com.yang.demo1;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableScheduling;

@SpringBootApplication
@EnableScheduling
public class ScheduledDemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(ScheduledDemoApplication.class, args);
    }
}

然后我们创建一个定时任务，并使用Scheduled注解

package com.yang.demo1;

import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

import java.text.SimpleDateFormat;
import java.util.Date;

@Component
public class DemoTask {
    @Scheduled(cron = "0/5 * * * * ?") // 每5秒执行一次
    public void execute() {
        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println("hello world: " + df.format(new Date()));
    }
}

启动项目，执行结果如下所示，每隔5秒，便会执行一次定时任务。
image.png
Scheduled注解类的源码如下：

package org.springframework.scheduling.annotation;
 
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Repeatable;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
 
@Target({ElementType.METHOD, ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Repeatable(Schedules.class)
public @interface Scheduled {
    String CRON_DISABLED = "-";
 
    String cron() default "";
 
    String zone() default "";
 
    long fixedDelay() default -1L;
 
    String fixedDelayString() default "";
 
    long fixedRate() default -1L;
 
    String fixedRateString() default "";
 
    long initialDelay() default -1L;
 
    String initialDelayString() default "";
}

除了刚才代码中使用到的cron参数，我们还可以使用fixedDelay和fixedRate等参数。fixedDelay和fixedRate很相似，但又略有不同，其中fixedDelay表示在某次任务执行完毕后，间隔fixedDelay的时间再执行，而fixedRate表示在某次任务执行开始后，间隔fixedRate的时间再执行。
我们对这两个参数，添加对应的测试方法：

  @Scheduled(fixedDelay = 5000)
    public void executeFixedDelay() {
        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println("executeFixedDelay开始执行了==========" + df.format(new Date()));
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    @Scheduled(fixedRate = 5000)
    public void executeFixedRate() {
        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println("executeFixedRate开始执行了==========" + df.format(new Date()));
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

启动项目，执行结果如下。我们可以看到，executeFixedDelay在任务执行完毕后，间隔5秒才执行下一个任务，也就是说，两个任务之间间隔7秒，而executeFixedRate在任务执行开始后，间隔5秒执行下一个任务，也就是两个任务之间间隔5秒。综上所示，fixedDelay和fixedRate之间的区别，其实就在于计算两个任务执行间隔时，需不需要考虑任务的执行时长。
image.png

基于SchedulingConfigurer接口

首先我们在数据库中创建t_cron表，并添加数据：

DROP TABLE IF EXISTS t_cron;
CREATE TABLE t_cron  (
  cron_id VARCHAR(30) NOT NULL PRIMARY KEY,
  cron VARCHAR(30) NOT NULL  
);
 
INSERT INTO t_cron VALUES ('1', '0/5 * * * * ?');

然后修改pom.xml，加上数据库的相关依赖：

  <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.4.3</version>
        </dependency>

修改配置文件：

spring:
  datasource:
    username: root
    password: 3fa4d180
    url: jdbc:mysql://localhost:3306/test01?useSSL=false&serverTimezone=UTC
    driver-class-name: com.mysql.cj.jdbc.Driver
mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

创建对应的mapper：

package com.yang.demo1.mapper;

import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;

@Mapper
public interface CronMapper {
    @Select("select cron from t_cron limit 1")
    String getCron();
}

然后，我们编写定时任务，通过读取我们在数据库设置好的执行周期，来执行定时任务，代码如下：

package com.yang.demo1;

import com.yang.demo1.mapper.CronMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.SchedulingConfigurer;
import org.springframework.scheduling.config.ScheduledTaskRegistrar;
import org.springframework.scheduling.support.CronTrigger;

import java.time.LocalDateTime;

@Configuration
@EnableScheduling
public class DynamicScheduleConfigurer implements SchedulingConfigurer {
    @Autowired
    private CronMapper cronMapper;

    @Override
    public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
        taskRegistrar.addTriggerTask(
                () -> execute(),
                triggerContext -> {
                    String cron = cronMapper.getCron();
                    if (StringUtils.isEmpty(cron)) {
                        throw new RuntimeException("cron 格式有误");
                    }
                    return new CronTrigger(cron).nextExecutionTime(triggerContext);
                }
        );
    }

    private void execute() {
        System.out.println("hello world:" + new Date());
    }
}

执行结果如下所示，一开始的cron是每5秒执行一次，后来我们修改cron，改为10秒执行一次，此时任务的执行频率，也随之我们数据库的修改动态地进行了调整。
image.png

EnableAsync注解

对于Scheduled，默认为单线程，当开启多个任务时，任务地执行实际会受到上一个任务执行时间地影响，所以需要使用Async注解，通过该注解开启多线程使任务之间不会相互影响。

ScheduledExecutorService执行定时任务

SpringBoot执行定时任务很简单，但是如果我们不使用SpringBoot，又该如何启动定时任务？这个时候，我们就可以使用ScheduledExecutorService接口，这个接口用于在一些预定义的延迟之后运行任务或定期运行任务。我们可以通过Executors类的工厂方法实例化ScheduledExecutorService，如下：

        ScheduledExecutorService scheduledExecutorService = Executors.newSingleThreadScheduledExecutor();

在ScheduledExecutorService接口中，有三个主要方法：
1）schedule：允许在指定的延迟后执行一次任务。
2）scheduleAtFixedRate：允许在指定的初始延迟后执行任务，然后以一定的周期重复执行，其中period参数用于指定两个任务的开始时间之间的间隔时间，因此任务执行的频率是固定的。
3）scheduleWithFixedDelay：类似于scheduleAtFixedRate，它也重复执行给定的任务，单period参数用于指定前一个任务的结束和下一个任务的开始之间的间隔时间，也就是指定下一个任务延时多久后才执行，执行频率可能会有所不同，具体取决于执行任务给定任务所需的时间。

schedule方法
package com.yang.demo2;

import java.util.Date;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class ScheduledExecutorServiceMain {
    public static void main(String[] args) {
        ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(1);
        scheduledExecutorService.schedule(() -> {
            System.out.println("Hello World:" + new Date());
        }, 1, TimeUnit.SECONDS);

        try {
            Thread.sleep(20000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        scheduledExecutorService.shutdown();
        try {
            if (!scheduledExecutorService.awaitTermination(10, TimeUnit.SECONDS)) {
                scheduledExecutorService.shutdownNow();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

结果如下：在延迟一秒后，开始执行任务，且只执行一次。
image.png

scheduleAtFixRate

当我们需要在固定延迟后，定期执行任务时，可以使用scheduleAtFixedRate方法，如下所示，每隔2秒执行相同的任务

public static void main(String[] args) {
        ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(1);
        scheduledExecutorService.scheduleAtFixedRate(() -> {
            System.out.println("Hello World:" + new Date());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, 0, 2, TimeUnit.SECONDS);

        try {
            Thread.sleep(20000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        scheduledExecutorService.shutdown();
        try {
            if (!scheduledExecutorService.awaitTermination(10, TimeUnit.SECONDS)) {
                scheduledExecutorService.shutdownNow();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

结果如下：
image.png
如果任务执行时间比间隔时间长，那么scheduledExecutorService将等待当前任务执行完毕后再开始执行下一个任务，我们修改代码如下：

 ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(4);
        scheduledExecutorService.scheduleAtFixedRate(() -> {
            System.out.println("Hello World:" + new Date());
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, 0, 2, TimeUnit.SECONDS);

        try {
            Thread.sleep(20000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        scheduledExecutorService.shutdown();
        try {
            if (!scheduledExecutorService.awaitTermination(10, TimeUnit.SECONDS)) {
                scheduledExecutorService.shutdownNow();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

结果如下，每隔3秒执行一次任务
image.png

scheduleWithFixedDelay方法

如果任务之间必须具有固定长度的延迟，那么可以使用scheduleWithFixedDelay方法。

  public static void main(String[] args) {
        ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(4);
        scheduledExecutorService.scheduleWithFixedDelay(() -> {
            System.out.println("Hello World:" + new Date());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, 0, 2, TimeUnit.SECONDS);

        try {
            Thread.sleep(20000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        scheduledExecutorService.shutdown();
        try {
            if (!scheduledExecutorService.awaitTermination(10, TimeUnit.SECONDS)) {
                scheduledExecutorService.shutdownNow();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

在上述代码中，任务执行时长需要1秒，然后设置的间隔时间为2秒，因此，我们可以看到，每隔任务之间，间隔3秒执行一次
image.png

【异常】为啥我的XXL-JOB的定时任务会执行失败？
本本本添哥
06-12 868
业务反馈，报表部分日期没有数据，这个数据是通过定时任务生成的，这个会让业务连续性降低横展其他日期，4月份一次执行失败，5月份一次执行失败，都是周日，报错都是一样的，500状态码。看XXL-job的执行日志，可以看到定时任务执行报错，报错如下，但是在ELK没有看到对应的日志。
定时任务框架xxl-job(使用、总结)
2303_79633394的博客
06-08 8607
任务调度是指系统为了自动完成特定任务，在约定的特定时刻去执行任务的过程。有了任务调度即可解放更多的人力，而是由系统自动去执行任务。某电商系统需要在每天上午10点，下午3点，晚上8点发放一批优惠券。某银行系统需要在信用卡到期还款日的前三天进行短信提醒。某财务系统需要在每天凌晨0:10结算前一天的财务数据，统计汇总。12306会根据车次的不同，设置某几个时间点进行分批放票。如何实现任务调度？多线程方式，结合sleepJDK提供的API，例如：Timer、ScheduledExecutor。
xxl-job定时任务调度
qq_35347070的博客
03-07 2433
xxl-job定时任务调度 单节点任务调度 Timer和TimerTask ScheduledExecutorService 三方框架 Quartz 分布式任务调度 elisticjob xxl-jb xxl-job elistic job对比 xxl elistic 中心节点调度 各任务节点抢占 依赖mysql zookeeper 向中心节点注册 调度时注册到zookeeper 支持动态分片 不支持动态分片 基于quartz二次
XXL-JOB定时任务基本使用
最新发布
qq_57404736的博客
05-17 2138
本文主要演示了目前主流定时任务XXL-JOB的基本使用及配置方法，方便快速上手
分布式任务调度平台XXL-JOB
qq_35354529的博客
01-19 726
XXL-JOB：分布式任务调度平台，特点：开发迅速、学习简单、轻量级、易扩展;具体介绍查看官网:https://www.xuxueli.com/xxl-job/ 1.下载xxl-job项目源码 https://gitee.com/xuxueli0323/xxl-job 2.快速入门 2.1 初始化“调度数据库” 请下载项目源码并解压，获取 “调度数据库初始化SQL脚本” 并执行即可。“调度数据库初始化SQL脚本” 位置为: /xxl-job/doc/db/tables_xxl_jo...
手撸XXL-JOB（二）——定时任务管理
weixin_55850954的博客
05-14 1512
在上一节中，我们介绍了SpringBoot中关于定时任务的执行方式，以及ScheduledExecutorService接口提供的定时任务执行方法。假设我们现在要写类似XXL-JOB这样的任务调度平台，那么，对于任务的管理，是尤为重要的。接下来我们将一步一步，实现一个任务调度管理类。
【xxl-job | 第一篇】Java实现定时任务的六种方法
踢桃的成长之路
05-06 2135
Java实现定时任务的六种方法
XXL-JOB：定时任务框架的实战应用与调度方式详解
热门推荐
小威的博客
07-17 2万+
XXL-JOB是一个轻量级分布式任务调度平台，它采用中心化设计，调度中心负责任务管理、调度，执行器负责任务执行。除此之外，XXL-JOB还支持多种调度模式，比如固定速率执行、Cron表达式等，满足不同业务场景的需求。那我们为什么现在就会使用分布式的调度框架呢？大家来看下面这个图：上面是一个发送优惠券的定时任务如果只是单体项目的话，定时任务执行是不会有任何问题的如果后期业务量较大，单体项目做了集群部署，那集群中每一台服务的代码都是一样的，都会按照规定的时间来执行任务，这样就会造成优惠券重复发放。
XXL-JOB调度中心——定时任务
qq_44760653的博客
02-28 753
4、将XxlJobConfig工具类导入service服务中。2、在项目工程的service工程添加依赖。3、在nacos上配置xxl-job。1、在调度中心新增一个执行器。
手撸XXL-JOB（三）——本地定时任务管理平台
weixin_55850954的博客
05-14 1114
为解决上述问题，我们可以通过事件的方式，进行解耦。在我的第一份实习中，遇到的项目，就是用事件的方式，来进行解耦，一开始我很不理解这种方式，因为发送的事件太多了，从开始到结束将近10个事件，每次看代码都要从一个事件处理类，跳到另一个事件处理类，但是后来看了一些DDD的书籍后，有点理解这种做法了，这种应该就是属于领域事件，因为这些事件，将不同子域串联起来，比如从收单到支付再到账户等域，通过领域事件，将这些不同的域串联起来，此外又不会使两个域之间存在强耦合的代码，从而方便后续的维护。
使用xxl-job-executor-go 接入xxl-job实现定时任务调度
lucky_ly的博客
05-18 1399
定时任务是软件开发中很常见的一种处理业务的机制，xxl-job是近些年比较火的定时任务调用组件，其采用java 实现，是一个高可用，分布式调用的组件，还支持多种定时任务有关的特性，不仅能轻易的用java 客户端接入，还提供了rest-api 供非java语言的客户端接入。
定时调度器 xxl-job
12-21
- **任务定义**：在执行器项目中编写具体的任务逻辑，通常以Spring Bean的形式存在，可以通过@XxlJob注解来定义任务。 - **任务调用**：调度中心通过HTTP或RPC方式调用执行器上的任务，任务执行的结果会反馈回调度...
定时任务调度框架xxl-job
梦想是很难很难的，所以先勇敢一点
07-23 1191
XXL-JOB是一个分布式任务调度平台，其核心设计目标是开发迅速、学习简单、轻量级、易扩展。现已开放源代码并接入多家公司线上产品线，开箱即用。
xxl-job定时任务测试
略简略烦的博客
07-13 754
启动相关xxl-job客户端服务后，会自动注册机器地址。
xxlJob 分布式定时任务
方圆师兄
07-14 1453
https://github.com/xuxueli/xxl-job 默认账号 admin 默认密码 123456 4.1 引入maven依赖 4.2 修改 application.yml 4.3 增加任务处理器 5. 将项目配置到 xxljob 中 5.1 配置执行器 5.2 配置任务 5.3 设置任务状态，也可以单独执行一次 5.4 查看日志信息.........
分布式定时任务xxl-Job
sv
07-10 2392
一款分布式的任务调度器xxl-job。xxl-job是一款极容易学习上手的轻量级开源分布式调度框架,分为管理端和执行端两块。
分布式定时调度：xxl-job 最佳实践
CVPR收割机的博客
12-20 1080
创建完成后需要创建对应的库和表，这里的库名定义为xxl_job（可以修改，注意和下面的docker-compose.yml文件中的配置保持一致）首先你需要有一个mysql的数据库，关于数据库的创建这里不做介绍，本地通过任何方式创建均可。之后访问：http://localhost:8787/xxl-job-admin/通过：admin/123456 即可登录查看效果。详细使用方法请参看最上面的官方文档，写的很详细。docker-compose.yml文件如下。注意替换上面连接的数据库的账号密码。
XXL-JOB定时任务(可以直接上手简单使用)
qq_54041019的博客
07-07 1642
xxl-job的快速使用，适合小白入门
Linux系统 xxl-job下载安装
mry6的博客
09-10 3189
Linux系统xxl-job下载安装xxl-job简介环境准备jar包部署xxl-job调度中心docker部署xxl-job调度中心 xxl-job简介 xxl-job 官网地址： https://www.xuxueli.com/xxl-job/ 1.概述 XXL-JOB是一个分布式任务调度平台，其核心设计目标是开发迅速、学习简单、轻量级、易扩展。现已开放源代码并接入多家公司线上产品线，开箱即用。 2.特性 (1) 简单：支持通过Web页面对任务进行CRUD操作，操作简单，一分钟上手； (2) 动态：支持
xxl-job任务调度中心使用
01-09
### 使用XXL-JOB任务调度中心配置和管理定时任务 #### 配置环境 为了能够顺利使用XXL-JOB进行任务调度，首先需要完成基本的安装与配置工作。这通常涉及到下载并部署XXL-JOB的服务端程序以及客户端SDK，并确保两者之间的网络通信畅通无阻。 #### 创建新任务 进入XXL-JOB管理员界面后，在左侧菜单栏找到“任务列表”，点击新增按钮即可创建一个新的调度任务。此时需填写任务名称、描述信息等内容[^1]。 #### 设置执行策略 对于每一个新建的任务而言，都需要指定具体的执行逻辑——即当该任务被触发时应该做什么操作；同时也要定义好其运行频率（Cron表达式）、超时时间等参数设置。这些都可以在编辑页面中的相应选项卡内完成配置[^2]。 #### 测试与调试 保存所作更改之后就可以尝试手动触发一次这个刚建立起来的新任务了。如果一切正常的话，则会看到状态变为成功；反之则可根据日志记录排查错误原因所在之处。 #### 安全注意事项 值得注意的是，在实际生产环境中应当特别关注系统的安全性问题。由于可能存在某些潜在的安全隐患（如命令注入），因此建议定期审查官方发布的安全公告并及时更新版本以修复已知漏洞[^3]。 ```bash # 示例：简单的Shell脚本作为任务执行体 #!/bin/bash echo "This is a test job" date >> /tmp/testjob.log ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值