xxl-job 初学(保姆级入门教程)

---

前言

这个分布式定时器官方文档（官网链接下面有）已经解释得很清楚了，我也不再赘述
我也是今天刚学的xxl-job，源码啥的也没看过，咱也不懂，以后再去深究，今天的目标只是如何快速的去使用这个分布式的定时器。

---

不多说，初学者最懂初学者

---

官网与源码下载地址

官网：https://www.xuxueli.com/xxl-job/
源码下载地址：https://github.com/xuxueli/xxl-job/releases

---

准备工作

1.下载源码

根据上面提供的 源码下载地址 链接进去下载源码就完事
windows 下使用下载这个就行了

下载源码之后解压

2.IDEA导入项目

导入之后是这样的

---

可以看到作者提供的源码里面主要分了三个模块

• xxl-job-admin
• xxl-job-core
• xxl-job-executor-samples

我们先看看 xxl-job-admin 这个模块

在启动这个模块之前先要做数据的准备工作

3.数据准备

先将所需要的表准备好，这里直接用作者提供的 sql 就行

复制 sql ，到你自己的数据库中执行

修改配置文件
这里改成你自己数据库的配置（你可以看看其它的配置信息，里面也有修改发送邮件等配置）

4.登陆任务调度中心

运行 xxl-job-admin 的启动类

启动完成后就可以登陆上去看看

地址：http://localhost:8080/xxl-job-admin

进去是这样子的，但是需要账号跟密码

其实账号和密码就在之前运行的sql之中

但是直接输入这个可不行，因为这个密码是通过md5加密而来的，真实的密码是 123456

账号：admin
密码：123456

输入账号和密码，登陆

登陆之后就能看任务调度中心的控制页面了

你可以自己点一下这个侧边栏，看看都有什么

现在控制平台已经开启了，那我要怎么添加我的定时任务呢？

5.测试定时任务

这里作者提供了 xxl-job 整合其它框架或者软件，这里我们先学习整合 spring-boot 的来，毕竟这个对于 java 开发是最重要的

可以看到整合了 spring-boot 的这个项目中的 pom 文件里是有引入这个 xxl-job-core 的依赖的

<!-- xxl-job-core -->
<dependency>
    <groupId>com.xuxueli</groupId>
    <artifactId>xxl-job-core</artifactId>
    <version>${project.parent.version}</version>
</dependency>

所以在我们自己的项目中如果到时候要用这个定时器，也需要加入这个依赖

作者这里也提供了 docker 的配置，需要在自己服务器上运行的可以使用

再来看看这个项目的配置文件

配置文件的内容如下：

# web port
server.port=8081
# no web
#spring.main.web-environment=false

# log config
logging.config=classpath:logback.xml

### xxl-job admin address list, such as "http://address" or "http://address01,http://address02"
# 这里主要是配置你任务调度中心的地址（就是控制平台的），如果你是本地起的就不需要改了，否则改成你服务器上的地址
xxl.job.admin.addresses=http://127.0.0.1:8080/xxl-job-admin

### xxl-job, access token
xxl.job.accessToken=

### xxl-job executor appname
xxl.job.executor.appname=xxl-job-executor-sample
### xxl-job executor registry-address: default use address to registry , otherwise use ip:port if address is null
xxl.job.executor.address=
### xxl-job executor server-info
xxl.job.executor.ip=
# 这个就是你定时器执行的端口,我这边改成使用服务自带的端口，然后再配置类中做个偏移处理，这样端口比较好维护点
xxl.job.executor.port=${server.port}
#xxl.job.executor.port=9999
### xxl-job executor log-path
xxl.job.executor.logpath=/data/applogs/xxl-job/jobhandler
### xxl-job executor log-retention-days
xxl.job.executor.logretentiondays=30

再看看配置类

内容如下：

@Configuration
public class XxlJobConfig {
    private Logger logger = LoggerFactory.getLogger(XxlJobConfig.class);

    @Value("${xxl.job.admin.addresses}")
    private String adminAddresses;

    @Value("${xxl.job.accessToken}")
    private String accessToken;

    @Value("${xxl.job.executor.appname}")
    private String appname;

    @Value("${xxl.job.executor.address}")
    private String address;

    @Value("${xxl.job.executor.ip}")
    private String ip;

    @Value("${xxl.job.executor.port}")
    private int port;

    @Value("${xxl.job.executor.logpath}")
    private String logPath;

    @Value("${xxl.job.executor.logretentiondays}")
    private int logRetentionDays;


    @Bean
    public XxlJobSpringExecutor xxlJobExecutor() {
        logger.info(">>>>>>>>>>> xxl-job config init.");
        XxlJobSpringExecutor xxlJobSpringExecutor = new XxlJobSpringExecutor();
        xxlJobSpringExecutor.setAdminAddresses(adminAddresses);
        xxlJobSpringExecutor.setAppname(appname);
        xxlJobSpringExecutor.setAddress(address);
        xxlJobSpringExecutor.setIp(ip);
        xxlJobSpringExecutor.setPort(port);
        xxlJobSpringExecutor.setAccessToken(accessToken);
        xxlJobSpringExecutor.setLogPath(logPath);
        xxlJobSpringExecutor.setLogRetentionDays(logRetentionDays);

        return xxlJobSpringExecutor;
    }

}

修改执行器端口偏移（这个看你自己的喜好，你可以自己去指定端口，我是直接拿服务的端口加上1000而的来执行器端口的）

成，那就直接运行下这个 xxl-job-executor-sample-spring 服务的启动类

启动之后去 任务调度中心 的 执行器管理 就能看到自动注入的执行器了，端口是9081，非常的 nice

好，我们再来回过头看看 任务调度中心 的 任务管理 ，之前我想大家都有看到这里有个默认的定时任务吧

这个定时任务其实就是 xxl-job-executor-sample-springboot 中的任务，可以在 SampleXxlJob.java 类中找到

那就来执行下这个定时器任务呗

再看看这个测试任务1 ，它的 cron 表达式是这样的0 0 0 * * ? *

在线Cron表达式生成器：https://cron.qqe2.com/

可以看到这个是每天凌晨 0 点执行，这可不成，那就改一改吧

在右侧 操作 - 编辑 可修改定时规则

修改这个 测试任务1 的执行规则为：每天 11:35 每 10 秒执行一次（因为我当前的时间是 11:30 ） cron表达式为: 0/10 35 11 * * ?

再去修改下这个项目的 demoJobHandler 定时任务，给它打印点东西，便于观察

重启该项目，清空控制台

启动下该定时任务

在右侧 操作 - 启动 启动该定时任务

到点了，就去控制台看看执行情况

可以看到控制台有六次打印（因为设置的就是 11:35 开始每 10 秒 执行一次）

也可以去查询这个定时任务的日志

---

整合到自己的项目中

现在对于怎么使用这个 xxl-job 应该都差不多了吧，现在我就把它整合到自己的项目中去

在我自己的项目新增模块 mike-xxl-job

简单处理下该模块的结构大概是这样

我这边配置文件用的是 yml 方式，使用了 nacos 管理我的配置，以下是我各个文件的内容

（以下内容需要根据项目自身的情况去配置，仅供参考）

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.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>mike-parent</artifactId>
        <groupId>com.mike</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>mike-xxl-job</artifactId>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <dependencies>
        <!-- 我的公共模块 -->
        <dependency>
            <groupId>com.mike</groupId>
            <artifactId>mike-common</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>

        <!-- nacos 服务发现 -->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        </dependency>

        <!-- spring-boot-starter-web (spring-webmvc + tomcat) -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

        <!-- lombok 依赖 -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>

        <!-- xxl-job-core -->
        <dependency>
            <groupId>com.xuxueli</groupId>
            <artifactId>xxl-job-core</artifactId>
            <version>2.3.0</version>
        </dependency>

    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <outputDirectory>${project.parent.basedir}/jars</outputDirectory>
                    <finalName>${project.artifactId}</finalName>
                    <!-- 指定该Main Class为全局的唯一入口 -->
                    <mainClass>com.mike.mo.job.XxlJobApplication</mainClass>
                    <layout>ZIP</layout>
                </configuration>
                <executions>
                    <execution>
                        <goals>
                            <goal>repackage</goal><!--可以把依赖的包都打包到生成的Jar包中-->
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

</project>

application.yml

server:
  port: 6804
logging:
  config: classpath:logback.xml
  file: /www/mike/project-mike/logs/mike-xxl-job.log
  level:
    com.alibaba.nacos: error
spring:
  application:
    name: mike-xxl-job
  main:
    allow-bean-definition-overriding: true
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8848
        namespace: f90ad91c-ac39-4a2d-8fb3-fcd33ded9123
  datasource:
    url: jdbc:mysql://127.0.0.1:3306/duojiala?characterEncoding=UTF-8&useSSL=false&serverTimezone=GMT%2B8
    hikari:
      username: 'root'
      password: 'root'
      driver-class-name: 'com.mysql.cj.jdbc.Driver'
      max-lifetime: 120000

xxl-job:
  admin:
    addresses: http://127.0.0.1:8080/xxl-job-admin
  executor:
    appName: mike-xxl-job
    ip:
    port: ${server.port}
    logPath: /data/applogs/xxl-job/jobhandler
    logRetentionDays: 30
  accessToken:

bootstrap.yml

spring:
  application:
    name: mk-xxl-job
  cloud:
    nacos:
      config:
        server-addr: 127.0.0.1:8848
        file-extension: yaml
        namespace: f90ad91c-ac39-4a2d-8fb3-fcd33ded9123
  profiles:
    active: local

logback.xml （这个是直接复制作者的，我也没研究过），也粘在下面

<?xml version="1.0" encoding="UTF-8"?>
<configuration debug="false" scan="true" scanPeriod="1 seconds">

    <contextName>logback</contextName>
    <property name="log.path" value="/data/applogs/xxl-job/xxl-job-executor-sample-springboot.log"/>

    <appender name="console" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%d{HH:mm:ss.SSS} %contextName [%thread] %-5level %logger{36} - %msg%n</pattern>
        </encoder>
    </appender>

    <appender name="file" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <file>${log.path}</file>
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <fileNamePattern>${log.path}.%d{yyyy-MM-dd}.zip</fileNamePattern>
        </rollingPolicy>
        <encoder>
            <pattern>%date %level [%thread] %logger{36} [%file : %line] %msg%n
            </pattern>
        </encoder>
    </appender>

    <root level="info">
        <appender-ref ref="console"/>
        <appender-ref ref="file"/>
    </root>

</configuration>

XxlJobApplication.java

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

MikeXxlJob.java

@Component
public class MikeXxlJob {
    private final static Logger logger = LoggerFactory.getLogger(MikeXxlJob.class);

    /**
     * 我的第一个定时器任务
     */
    @XxlJob("funJobHandler")
    public void funJobHandler() {
        System.out.println("啊~我执行了~~~~");
    }
}

我将 xxl-job 的配置整合成一个bean对象，跟之前的 properties 配置文件方式有点不太一样

XxlJobBeanConfig.java

@Component
@ConfigurationProperties(prefix = "xxl-job")
@Data
public class XxlJobBeanConfig {
    private Admin admin;
    private Executor executor;
    private String accessToken;

    @Data
    public static class Executor {
        private String appName;
        private String ip;
        private int port;
        private String logPath;
        private int logRetentionDays;
    }

    @Data
    public static class Admin {
        private String addresses;
    }
}

XxlJobConfig.java xxl-job 定时器配置类

@Configuration
@RequiredArgsConstructor(onConstructor = @__(@Autowired))
public class XxlJobConfig {
    private final Logger logger = LoggerFactory.getLogger(XxlJobConfig.class);

    private final XxlJobBeanConfig bean;

    @Bean
    public XxlJobSpringExecutor xxlJobExecutor() {
        logger.info(">>>>>>>>>>> xxl-job config init.");
        XxlJobSpringExecutor xxlJobSpringExecutor = new XxlJobSpringExecutor();
        xxlJobSpringExecutor.setAdminAddresses(bean.getAdmin().getAddresses());
        xxlJobSpringExecutor.setAppname(bean.getExecutor().getAppName());
        xxlJobSpringExecutor.setAddress(bean.getAdmin().getAddresses());
        xxlJobSpringExecutor.setIp(bean.getExecutor().getIp());
        xxlJobSpringExecutor.setPort(bean.getExecutor().getPort()+1000); //端口向后偏移1000
        xxlJobSpringExecutor.setAccessToken(bean.getAccessToken());
        xxlJobSpringExecutor.setLogPath(bean.getExecutor().getLogPath());
        xxlJobSpringExecutor.setLogRetentionDays(bean.getExecutor().getLogRetentionDays());

        return xxlJobSpringExecutor;
    }
}

以上就是我这个定时器模块的全部代码了，现在就来运行下 mike-xxl-job 的启动类

回到 任务调度中心 - 执行器管理 ，刷新好像也没看到刚刚启动的服务也没有注册到这个管理当中，那就自己 新增 吧

然后就能再 执行器管理 中看到新建的执行器了

去 任务管理 新增定时任务

设置好定时规则，启动新增的这个定时任务

时间到点，我的定时任务也执行了

查看下调度日志

---

总结

这就是 xxl-job 快速入门的全部内容，还有一些内容没有添加进来，大家可自行学习，等我有一定的实战经验之后再来做深入一点的研究并分享给大家。