hello，大家好，我是灰小猿
近期开发中的功能中需要用到定时任务来做数据库的备份和文件的定时删除，所以调研了当前比较主流的几个定时任务框架，经过对比选定了今天要讲的xxl-job，所以这篇文章，我主要和大家分享一下xxl-job的学习总结，记录一下在分布式项目下如何优雅的使用xxl-job实现定时任务。
在使用xxl-job之前也对市面上现有的一些定时任务框架做了对比，具体如下：
考虑到我们是分布式项目，且定时任务的业务处理相对来说比较独立，所以在选择定时任务框架时，我们需要考虑一些关键因素，而 Xxl-job 恰好满足这些需求：
综上所述，我们最终确定以xxl-job作为我们的定时任务框架。
接下来和大家介绍一下xxl-job的基本原理和实际使用：
XXL-JOB是一个轻量级分布式任务调度平台。特点是平台化，易部署，开发迅速、学习简单、轻量级、易扩展。
它主要是由调度中心和执行器功能完成定时任务的执行。其中调度中心负责统一调度，执行器负责接收调度并执行。并且 现在xxl-job已经开放源代码并接入多家公司的线上产品线，开箱即用。所以相对来说可以参考的资料很多，技术实现也相对比较成熟，xxl-job提供了非常完善的帮助文档，感兴趣的小伙伴也可以去阅读以下：
Xxl-job设计思想：
xxl-job的设计思想可以与Nacos类似，xxl-job的调度中心就可以看做是nacos的注册中心，nacos是将一个个服务注册到nacos注册中心，而xxl-job是将一个个定时任务注册到“调度中心”。
Xxl-job的主要架构
调度模块（调度中心）
负责管理调度信息，按照调度配置发出调度请求，自身不承担业务代码。调度系统与任务解耦，提高了系统可用性和稳定性，同时调度系统性能不再受限于任务模块；
支持可视化、简单且动态的管理调度信息，包括任务新建，更新，删除，GLUE开发和任务报警等，所有上述操作都会实时生效，同时支持监控调度结果以及执行日志，支持执行器Failover。
调度中心界面：
执行模块（执行器）
负责接收“调度中心”的调度并执行任务逻辑。任务模块专注于任务的执行等操作，开发和维护更加简单和高效；接收“调度中心”的执行请求、终止请求和日志请求等。
以下是Xxl-job整体的项目架构图：
Xxl-Job架构图
步骤一：拉取Xxl-job项目到本地
首先去gitee拉取xxl-job的项目源码，建议选用较新且稳定的版本，我选择的是V2.2.0版本，
项目地址：
导入项目到IDEA之后，项目结构如下：
步骤二；配置调度中心
首先在doc文件夹下找到源码中带的sql脚本文件，在本地mysql下运行该脚本文件，之后就可以生成一个调度中心的数据库，该数据库主要用于对后面调度中心配置的一些数据进行存储和统计。
sql脚本中的数据表功能说明如下：
xxl-job数据库表介绍
配置中心主要配置
数据库生成完毕后，需要去调度中心的配置文件中对调度中心进行配置，
配置中心主要配置如下：
### xxl-job, datasource 调度中心数据库连接，连接本地数据库
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/xxl_job?useUnicode=true&characterEncoding=UTF-8&autoReconnect=true&serverTimezone=Asia/Shanghai
spring.datasource.username=root
spring.datasource.password=root_pwd
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
### datasource-pool 数据库连接池配置
spring.datasource.type=com.zaxxer.hikari.HikariDataSource
spring.datasource.hikari.minimum-idle=10
spring.datasource.hikari.maximum-pool-size=30
spring.datasource.hikari.auto-commit=true
spring.datasource.hikari.idle-timeout=30000
spring.datasource.hikari.pool-name=HikariCP
spring.datasource.hikari.max-lifetime=900000
spring.datasource.hikari.connection-timeout=10000
spring.datasource.hikari.connection-test-query=SELECT 1
### xxl-job, email 配置邮箱服务器，用于执行或调度异常时发送报警邮件
spring.mail.host=smtp.qq.com
spring.mail.port=25
spring.mail.username=xxx@qq.com
spring.mail.password=xxx
spring.mail.properties.mail.smtp.auth=true
spring.mail.properties.mail.smtp.starttls.enable=true
spring.mail.properties.mail.smtp.starttls.required=true
spring.mail.properties.mail.smtp.socketFactory.class=javax.net.ssl.SSLSocketFactory
### xxl-job, access token 认证token，这个token要和执行器的token一致，用于调度中心和执行器互相认证
xxl.job.accessToken=
### xxl-job, i18n (default is zh_CN, and you can choose "zh_CN", "zh_TC" and "en") 国际化配置
xxl.job.i18n=zh_CN
## xxl-job, triggerpool max size 线程池配置
xxl.job.triggerpool.fast.max=200
xxl.job.triggerpool.slow.max=100
### xxl-job, log retention days 调度中心日志文件保存天数，默认是大于等于7天时生效，小于7或为-1时默认是不保存日志
xxl.job.logretentiondays=30至此，调度中心就配置完成了，直接启动admin服务，访问默认地址：
即可进入调度中心首页，默认登录账号 “admin/123456”, 登录后运行界面如下图所示：
步骤三：配置执行器
# 服务器端口
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 认证token，这个token要和执行器的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
### 执行器执行定时任务的地址，这个地址和下面的ip、port选择配置即可
xxl.job.executor.address=
### xxl-job executor server-info 执行器执行定时任务的地址和端口号，这个端口号和上面执行器服务的端口号不能一样
xxl.job.executor.ip=127.0.0.1
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 执行器端的操作日志保存天数，大于等于3时生效，小于3或为-1时默认不保存
xxl.job.executor.logretentiondays=30执行器实现原理
执行器实际上是一个内嵌的Server，默认端口9999（配置项：xxl.job.executor.port）。
在项目启动时，执行器会通过“@JobHandler”识别Spring容器中“Bean模式任务”，以注解的value属性为key管理起来。
“执行器”接收到“调度中心”的调度请求时，如果任务类型为“Bean模式”，将会匹配Spring容器中的“Bean模式任务”，然后调用其execute方法，执行任务逻辑。
如果任务类型为“GLUE模式”，将会加载GLUE代码，实例化Java对象，注入依赖的Spring服务（注意：Glue代码中注入的Spring服务，必须存在与该“执行器”项目的Spring容器中），然后调用execute方法，执行任务逻辑。
步骤四：编写任务执行代码
编写任务执行代码有两种方式，一种是通过Bean模式在后台编写任务代码，另一种则是通过GLUE模式直接在调度中心写任务脚本，下面我们分别介绍下在每一种方式下的使用。
任务运行模式
Bean模式（类形式）
Bean模式任务，支持基于类的开发方式，每个任务对应一个Java类。
优点：
缺点：
这种方式一般适用于非框架项目，具体开发步骤如下：
1、在执行器（也可能是你的项目模块）的properties文件中配置xxl.job的相关配置
2、实现定时任务的类继承"IJobHandler"：“com.xxl.job.core.handler.IJobHandler”；
3、在execute()方法中编写对应的任务代码
package com.xuxueli.executor.sample.frameless.jobhandler;
import com.xxl.job.core.biz.model.ReturnT;
import com.xxl.job.core.handler.IJobHandler;
import com.xxl.job.core.log.XxlJobLogger;
import java.util.concurrent.TimeUnit;
/**
* 任务Handler示例（Bean模式）
*
* 开发步骤：
* 1、继承"IJobHandler"：“com.xxl.job.core.handler.IJobHandler”；
* 2、注册到执行器工厂：在 "JFinalCoreConfig.initXxlJobExecutor" 中手动注册，注解key值对应的是调度中心新建任务的JobHandler属性的值。
* 3、执行日志：需要通过 "XxlJobLogger.log" 打印执行日志；
*
* @author xuxueli 2015-12-19 19:43:36
*/
public class DemoJobHandler extends IJobHandler {
@Override
public ReturnT<String> execute(String param) throws Exception {
XxlJobLogger.log("XXL-JOB, Hello World.");
for (int i = 0; i < 5; i++) {
XxlJobLogger.log("beat at:" + i);
TimeUnit.SECONDS.sleep(2);
}
return SUCCESS;
}
}4、编写FrameLessXxlJobConfig配置文件，用于注册定时任务类
5、注册到执行器工厂：在 "JFinalCoreConfig.initXxlJobExecutor" 中手动注册，注解key值对应的是调度中心新建任务的JobHandler属性的值。3、执行日志：需要通过 "XxlJobLogger.log" 打印执行日志；
package com.xuxueli.executor.sample.frameless.config;
import com.xuxueli.executor.sample.frameless.jobhandler.CommandJobHandler;
import com.xuxueli.executor.sample.frameless.jobhandler.DemoJobHandler;
import com.xuxueli.executor.sample.frameless.jobhandler.HttpJobHandler;
import com.xuxueli.executor.sample.frameless.jobhandler.ShardingJobHandler;
import com.xxl.job.core.executor.XxlJobExecutor;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Properties;
/**
* @author xuxueli 2018-10-31 19:05:43
*/
public class FrameLessXxlJobConfig
private XxlJobExecutor xxlJobExecutor = null;
/**
* init
*/
public void initXxlJobExecutor() catch (Exception e)
}
/**
* destory
*/
public void destoryXxlJobExecutor()
}
public static Properties loadProperties(String propertyFileName)
} catch (IOException e) {
logger.error("load {} error!", propertyFileName);
} finally catch (IOException e) {
logger.error("close {} error!", propertyFileName);
}
}
}
return null;
}
}Bean模式（方法形式）
Bean模式任务，支持基于方法的开发方式，每个任务对应一个方法。
优点：
缺点：
在Bean模式下采用方法形式编写定时任务的方式对spring项目更加的友好，而且使用也更加简单方便，所以一般推荐使用这种方式来编写定时任务。
实现步骤大体上和类形式类似，但是不同点就是在于采用方法形式不需要每一个任务都建立一个新的类。具体的开发步骤如下：
1、在执行器（也可能是你的项目模块）的properties或yaml文件中配置xxl.job的相关配置，具体配置在上面执行器配置那里已经说过了
2、在Spring Bean实例中，开发Job方法，方式格式要求为 "public ReturnT<String> execute(String param)"
3、为Job方法添加注解 "@XxlJob(value="自定义jobhandler名称", init = "JobHandler初始化方法", destroy = "JobHandler销毁方法")"，注解value值对应的是调度中心新建任务的JobHandler属性的值。
package com.xxl.job.executor.service.jobhandler;
import com.xxl.job.core.biz.model.ReturnT;
import com.xxl.job.core.handler.IJobHandler;
import com.xxl.job.core.handler.annotation.XxlJob;
import com.xxl.job.core.log.XxlJobLogger;
import com.xxl.job.core.util.ShardingUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.DataOutputStream;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.Arrays;
import java.util.concurrent.TimeUnit;
/**
* XxlJob开发示例（Bean模式）
*
* 开发步骤：
* 1、在Spring Bean实例中，开发Job方法，方式格式要求为 "public ReturnT<String> execute(String param)"
* 2、为Job方法添加注解 "@XxlJob(value="自定义jobhandler名称", init = "JobHandler初始化方法", destroy = "JobHandler销毁方法")"，注解value值对应的是调度中心新建任务的JobHandler属性的值。
* 3、执行日志：需要通过 "XxlJobLogger.log" 打印执行日志；
*
* @author xuxueli 2019-12-11 21:52:51
*/
@Component
public class SampleXxlJob
return ReturnT.SUCCESS;
}
/**
* 2、分片广播任务
*/
@XxlJob("shardingJobHandler")
public ReturnT<String> shardingJobHandler(String param) throws Exception , 总分片数 = {}", shardingVO.getIndex(), shardingVO.getTotal());
// 业务逻辑
for (int i = 0; i < shardingVO.getTotal(); i++) 片, 命中分片开始处理", i);
} else {
XxlJobLogger.log("第 {} 片, 忽略", i);
}
}
return ReturnT.SUCCESS;
}
/**
* 3、命令行任务
*/
@XxlJob("commandJobHandler")
public ReturnT<String> commandJobHandler(String param) throws Exception
// command exit
process.waitFor();
exitValue = process.exitValue();
} catch (Exception e) {
XxlJobLogger.log(e);
} finally
}
if (exitValue == 0) {
return IJobHandler.SUCCESS;
} else
}
/**
* 4、跨平台Http任务
* 参数示例：
* "url: http://www.baidu.com
" +
* "method: get
" +
* "data: content
";
*/
@XxlJob("httpJobHandler")
public ReturnT<String> httpJobHandler(String param) throws Exception
String[] httpParams = param.split("
");
String url = null;
String method = null;
String data = null;
for (String httpParam: httpParams)
if (httpParam.startsWith("method:")) {
method = httpParam.substring(httpParam.indexOf("method:") + 7).trim().toUpperCase();
}
if (httpParam.startsWith("data:")) {
data = httpParam.substring(httpParam.indexOf("data:") + 5).trim();
}
}
// param valid
if (url==null || url.trim().length()==0) {
XxlJobLogger.log("url["+ url +"] invalid.");
return ReturnT.FAIL;
}
if (method==null || !Arrays.asList("GET", "POST").contains(method)) {
XxlJobLogger.log("method["+ method +"] invalid.");
return ReturnT.FAIL;
}
// request
HttpURLConnection connection = null;
BufferedReader bufferedReader = null;
try
// valid StatusCode
int statusCode = connection.getResponseCode();
if (statusCode != 200) {
throw new RuntimeException("Http Request StatusCode(" + statusCode + ") Invalid.");
}
// result
bufferedReader = new BufferedReader(new InputStreamReader(connection.getInputStream(), "UTF-8"));
StringBuilder result = new StringBuilder();
String line;
while ((line = bufferedReader.readLine()) != null) {
result.append(line);
}
String responseMsg = result.toString();
XxlJobLogger.log(responseMsg);
return ReturnT.SUCCESS;
} catch (Exception e) {
XxlJobLogger.log(e);
return ReturnT.FAIL;
} finally
if (connection != null) {
connection.disconnect();
}
} catch (Exception e2) {
XxlJobLogger.log(e2);
}
}
}
/**
* 5、生命周期任务示例：任务初始化与销毁时，支持自定义相关逻辑；
*/
@XxlJob(value = "demoJobHandler2", init = "init", destroy = "destroy")
public ReturnT<String> demoJobHandler2(String param) throws Exception {
XxlJobLogger.log("XXL-JOB, Hello World.");
return ReturnT.SUCCESS;
}
public void init(){
logger.info("init");
}
public void destroy(){
logger.info("destory");
}
}4、执行日志：需要通过 "XxlJobLogger.log" 打印执行日志；
5、编写XxlJobConfig配置文件，用于读取配置文件中配置的XXL-JOB配置
package com.xxl.job.executor.core.config;
import com.xxl.job.core.executor.impl.XxlJobSpringExecutor;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/**
* xxl-job config
*
* @author xuxueli 2017-04-28
*/
@Configuration
public class XxlJobConfig ")
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()
/**
* 针对多网卡、容器内部署等情况，可借助 "spring-cloud-commons" 提供的 "InetUtils" 组件灵活定制注册IP；
*
* 1、引入依赖：
* <dependency>
* <groupId>org.springframework.cloud</groupId>
* <artifactId>spring-cloud-commons</artifactId>
* <version>${version}</version>
* </dependency>
*
* 2、配置文件，或者容器启动变量
* spring.cloud.inetutils.preferred-networks: 'xxx.xxx.xxx.'
*
* 3、获取IP
* String ip_ = inetUtils.findFirstNonLoopbackHostInfo().getIpAddress();
*/
}参考上述方法就可以在采用Bean模式在代码中编写定时任务了，
那么采用这种方式实现的定时任务，他具体的工作原理是怎样的呢？
实现原理
每个Bean模式任务都是一个Spring的Bean类实例，它被维护在“执行器”项目的Spring容器中。任务类需要加“@JobHandler(value=”名称”)”注解，因为“执行器”会根据该注解识别Spring容器中的任务。
任务类需要继承统一接口“IJobHandler”，任务逻辑在execute方法中开发，因为“执行器”在接收到调度中心的调度请求时，将会调用“IJobHandler”的execute方法，执行任务逻辑。
上面说了，除了在项目中编写定时任务的代码外，还有一种直接在调度中心编写定时任务脚本的方式，这种方式的好处就是即使你的项目已经上线，仍然可以添加或删除定时任务，无需暂停项目。
GLUE模式（Java）
GLUE模式任务，任务以源码方式维护在调度中心，支持通过Web IDE在线更新，实时编译和生效，因此不需要指定JobHandler。
开发步骤：
1、调度中心新建调度任务
2、进入GLUE IDE，直接在调度中心开发任务代码（支持代码版本回溯）
3、开启执行即可启动任务
GLUE模式（Shell、Python、PHP、NodeJS、Powershell）
GLUE模式任务的其他语言脚本，执行步骤和Java脚本一样，在这里就不做赘述了。
开发步骤：
那么这种采用在调度中心直接编写脚本的方式来执行定时任务的方法，具体的实现原理是什么呢？
实现原理
脚本任务的源码托管在调度中心，脚本逻辑在执行器运行。当触发脚本任务时，执行器会加载脚本源码在执行器机器上生成一份脚本文件，然后通过Java代码调用该脚本；并且实时将脚本输出日志写到任务日志文件中，从而在调度中心可以实时监控脚本运行情况；
步骤五：注册任务到调度中心
注册任务到调度中心的操作主要是针对于采用Bean模式编写执行任务的情况，因为这种情况下在没有注册任务到调度中心的时候，调度中心是不知道要将哪些任务作为调度任务的，
GLUE模式之所以不需要这一步骤是因为GLUE模式在新建任务的时候就是一个注册任务到调度中心的过程了。
以Bean模式下注册任务为例：
1、首先在界面右侧点击新建，新建任务。
2、在弹出的新建任务窗口中，选择BEAN模式，这时对应右侧的JobHandler输入框是使能的，此时在这里输入你要注册的任务的唯一ID，也就是你在后台代码中标识这个任务时使用的名称。
3、填写完其他必填项之后，任务就注册成功了。
下面就是使用调度中心去执行任务，
步骤六：调度中心执行任务
无论是BEAN模式还是GLUE模式下新建（注册）的任务，在新建完成后，任务都是不会立即执行的，所以需要我们在想要执行任务的时候手动的去启动任务，
启动任务的操作如下：
查看任务调度日志
任务执行之后，想要查看任务执行成功或者失败，可以去“调度日志”模块查看，点击调度备注列的查看，也可以查看具体的失败原因。
以上就是整个调度任务的执行流程，对上面的流程做一下总结：
一次完整的任务调度通讯流程
下面列出了在实际项目中可能会使用到Xxl-job来作为分布式任务框架执行定时任务的场景，都是为了让业务之外的操作变得更加的简单高效。具体如下：
以上就是关于分布式调度任务XXL-JOB使用的全部教程及原理分享，有问题的小伙伴可以留言或私信我一起学习。
我是灰小猿，我们下期见！
