学习链接

xxl-job官方文档

XXL-JOB快速入门（什么是XXL-JOB、部署XXL-JOB、在SpringBoot项目中接入XXL-JOB、XXL-JOB中的核心概念、集群环境下任务的路由策略）

定时任务——xxl-job原理与实现

xxl-job源码解析(看这一篇就够了，超简约且详细)

Idea中一个服务同时启动多个端口（超详细）

【分布式任务调度】三、XXL-JOB详细介绍

XXL-JOB分布式任务调度框架(一)-基础入门
XXL-JOB分布式任务调度框架(二)-策略详解
XXL-JOB分布式任务调度框架(三)-集群部署
XXL-JOB分布式任务调度框架(四)-源码分析-调度中心对执行器的上下线感知实现原理
XXL-JOB分布式任务调度框架(五)-源码分析-任务调度执行流程及实现原理

xxl-job详细使用指南

分布式任务调度平台之XXL-Job保姆级教学

SpringBoot项目集成xxljob全纪录（图文详解）

分布式调度XXL-JOB

1.概述

1.1什么是任务调度

我们可以思考一下下面业务场景的解决方案:

• 某电商平台需要每天上午10点，下午3点，晚上8点发放一批优惠券
• 某银行系统需要在信用卡到期还款日的前三天进行短信提醒
• 某财务系统需要在每天凌晨0:10分结算前一天的财务数据，统计汇总

以上场景就是任务调度所需要解决的问题

任务调度是为了自动完成特定任务，在约定的特定时刻去执行任务的过程

常见的任务调度方式

Timer

Timer timer = new Timer();
TimerTask task = new TimerTask() {
    public void run() {
        System.out.println("开始运行");
    }
};
timer.schedule(task, 2000);
//2秒后开始启动任务
timer.schedule(task, 2000, 5000);//2秒后开始任务，然后每隔五秒执行一次

ScheduledExecutorService

public void scheduleTask() {
    ScheduledExecutorService task = Executors.newScheduledThreadPool(5);
    task.scheduleAtFixedRate(new Runnable() {
        @Override
        public void run() {

        }
    }, 5, 30, TimeUnit.MINUTES); //5秒后开始执行线程，然后每隔30分钟执行一次

}

@Scheduled

spring提供的@Scheduled注解

Quartz

Quartz定时任务

1.2 为什么需要分布式调度

使用Spring中提供的注解@Scheduled，也能实现调度的功能

在业务类中方法中贴上这个注解,然后在启动类上贴上@EnableScheduling注解

@Scheduled(cron = "0/20 * * * * ? ")
 public void doWork(){
 	//doSomething   
 }

感觉Spring给我们提供的这个注解可以完成任务调度的功能，好像已经完美解决问题了，为什么还需要分布式呢?

主要有如下这几点原因:

1. 高可用：单机版的定式任务调度只能在一台机器上运行，如果程序或者系统出现异常就会导致功能不可用。
2. 防止重复执行: 在单机模式下，定时任务是没什么问题的。但当我们部署了多台服务，同时又每台服务又有定时任务时，若不进行合理的控制在同一时间，只有一个定时任务启动执行，这时，定时执行的结果就可能存在混乱和错误了
3. 单机处理极限：原本1分钟内需要处理1万个订单，但是现在需要1分钟内处理10万个订单；原来一个统计需要1小时，现在业务方需要10分钟就统计出来。你也许会说，你也可以多线程、单机多进程处理。的确，多线程并行处理可以提高单位时间的处理效率，但是单机能力毕竟有限（主要是CPU、内存和磁盘），始终会有单机处理不过来的情况。

1.3 XXL-JOB介绍

XXL-Job：是大众点评的分布式任务调度平台，是一个轻量级分布式任务调度平台, 其核心设计目标是开发迅速、学习简单、轻量级、易扩展

大众点评目前已接入XXL-JOB，该系统在内部已调度约100万次，表现优异。

目前已有多家公司接入xxl-job，包括比较知名的大众点评，京东，优信二手车，360金融 (360)，联想集团 (联想)，易信 (网易)等等

官网地址 https://www.xuxueli.com/xxl-job/

系统架构图

设计思想

将调度行为抽象形成“调度中心”公共平台，而平台自身并不承担业务逻辑，“调度中心”负责发起调度请求。

将任务抽象成分散的JobHandler，交由“执行器”统一管理，“执行器”负责接收调度请求并执行对应的JobHandler中业务逻辑。

因此，“调度”和“任务”两部分可以相互解耦，提高系统整体稳定性和扩展性；

2.快速入门

2.1 下载源码

源码下载地址:

https://github.com/xuxueli/xxl-job

https://gitee.com/xuxueli0323/xxl-job

（1、克隆源码：git clone https://gitee.com/xuxueli0323/xxl-job，

​ 2、切换分支：git checkout -b 2.3.1 origin/2.3.1（jdk8版本、boot2.6.7））

2.1 初始化调度数据库

请下载项目源码并解压，获取 “调度数据库初始化SQL脚本” 并执行即可。

“调度数据库初始化SQL脚本” 位置为:

/xxl-job/doc/db/tables_xxl_job.sql

2.2 编译源码

解压源码,按照maven格式将源码导入IDE, 使用maven进行编译即可，源码结构如下：

2.3 配置部署调度中心

2.3.1 调度中心配置

修改xxl-job-admin项目的配置文件application.properties,把数据库账号密码配置上

### web
server.port=8080
server.servlet.context-path=/xxl-job-admin

### actuator
management.server.servlet.context-path=/actuator
management.health.mail.enabled=false

### resources
spring.mvc.servlet.load-on-startup=0
spring.mvc.static-path-pattern=/static/**
spring.resources.static-locations=classpath:/static/

### freemarker
spring.freemarker.templateLoaderPath=classpath:/templates/
spring.freemarker.suffix=.ftl
spring.freemarker.charset=UTF-8
spring.freemarker.request-context-attribute=request
spring.freemarker.settings.number_format=0.##########

### mybatis
mybatis.mapper-locations=classpath:/mybatis-mapper/*Mapper.xml
#mybatis.type-aliases-package=com.xxl.job.admin.core.model

### 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
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
spring.datasource.hikari.validation-timeout=1000

### xxl-job, email
spring.mail.host=smtp.qq.com
spring.mail.port=25
spring.mail.username=xxx@qq.com
spring.mail.from=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
xxl.job.accessToken=default_token

### 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
xxl.job.logretentiondays=30

2.3.2 部署项目

运行XxlJobAdminApplication程序即可.

调度中心访问地址: http://localhost:8080/xxl-job-admin

默认登录账号 “admin/123456”, 登录后运行界面如下图所示。

至此“调度中心”项目已经部署成功。

2.4 配置部署执行器项目

可以参考xxl-job源码中的xxl-job-executor-samples中的的示例项目，配置执行器

2.4.1 添加Maven依赖

创建SpringBoot项目并且添加如下依赖:

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

（1、需要先在xxl-job源码中，先点击xxl-job(root)打包成依赖

​ 2、这里与xxl-job-core 2.3.1版本的springboot版本是2.6.7，jdk版本是8）

2.4.2 执行器配置

在配置文件中添加如下配置:

### （执行器所在项目的web端口）
server.port=8081

### 调度中心部署根地址 [选填]：如调度中心集群部署存在多个地址则用逗号分隔。执行器将会使用该地址进行"执行器心跳注册"和"任务结果回调"；为空则关闭自动注册；
xxl.job.admin.addresses=http://127.0.0.1:8080/xxl-job-admin
### 执行器通讯TOKEN [选填]：非空时启用；
xxl.job.accessToken=default_token
### 执行器AppName [选填]：执行器心跳注册分组依据；为空则关闭自动注册
### （注意：这里注册要填写执行器管理中已存在的AppName，默认会有1个xxl-job-executor-sample。如果自己定义的名字与之不一样的话，可以在调度中心执行器管理页面上手动新增，然后启动执行器所在的项目，就可以在调度中心执行器管理页面看到了）
xxl.job.executor.appname=xxl-job-executor-sample
### 执行器注册 [选填]：优先使用该配置作为注册地址，为空时使用内嵌服务 ”IP:PORT“ 作为注册地址。从而更灵活的支持容器类型执行器动态IP和动态映射端口问题。
### （配置例如：127.0.0.1:9999）
xxl.job.executor.address=
### 执行器IP [选填]：默认为空表示自动获取IP，多网卡时可手动设置指定IP，该IP不会绑定Host仅作为通讯实用；地址信息用于 "执行器注册" 和 "调度中心请求并触发任务"；
xxl.job.executor.ip=127.0.0.1
### 执行器端口号 [选填]：小于等于0则自动获取；默认端口为9999，单机部署多个执行器时，注意要配置不同执行器端口；
### （注意不是应用启动的端口号，而是执行器与调度中心通信时使用的端口号）
xxl.job.executor.port=9999
### 执行器运行日志文件存储磁盘路径 [选填] ：需要对该路径拥有读写权限；为空则使用默认路径；
xxl.job.executor.logpath=/data/applogs/xxl-job/jobhandler
### 执行器日志文件保存天数 [选填] ： 过期日志自动清理, 限制值大于等于3时生效; 否则, 如-1, 关闭自动清理功能；
xxl.job.executor.logretentiondays=30

2.4.3 添加执行器配置

创建XxlJobConfig配置对象:

@Configuration
public class XxlJobConfig {
    @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() {
        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;
    }
}

2.4.4 添加任务处理类

添加任务处理类，交给Spring容器管理，在处理方法上贴上@XxlJob注解

@Component
public class SimpleXxlJob {
    @XxlJob("demoJobHandler")
    public void demoJobHandler() throws Exception {
        System.out.println("执行定时任务,执行时间:"+new Date());
    }
}

2.5 运行HelloWorld程序

2.5.1 任务配置&触发执行

登录调度中心,在任务管理中新增任务,配置内容如下:

（选择对应的执行器和填入对应的执行器中使用@XxlJob(“demoJobHandler”)标注的demoJobHandler）

新增后界面如下:

接着启动定时调度任务

2.5.2 查看日志

在调度中心的调度日志中就可以看到，任务的执行结果.

管控台也可以看到任务的执行信息.

（以上就是调度中心使用Bean模式来调 度执行器中使用@XxlJob注解所标注的方法的任务）

2.6 GLUE模式(Java)

任务以源码方式维护在调度中心，支持通过Web IDE在线更新，实时编译和生效，因此不需要指定JobHandler。

（ “GLUE模式(Java)” 运行模式的任务实际上是一段继承自IJobHandler的Java类代码，它在执行器项目中运行，可使用@Resource/@Autowire注入执行器里中的其他服务.

添加Service

（HelloService代码写在对应的执行器所在的项目中，但未使用@XxlJob标记为任务，但是现在需要通过调度中心设置的glue模式，执行到HelloService中的methodA方法）

@Service
public class HelloService {
    public void methodA(){
        System.out.println("执行MethodA的方法");
    }
    public void methodB(){
        System.out.println("执行MethodB的方法");
    }
}

添加任务配置

通过GLUE IDE在线编辑代码

---

编写内容如下:

（只要下面代码能通过编辑即可，不一定要在com.xxl.job.service.handler这个包中；这段代码必须在对应的执行器中可以通过编译；代码要全，包括导包声明；）

package com.xxl.job.service.handler;

import cn.wolfcode.xxljobdemo.service.HelloService;
import com.xxl.job.core.handler.IJobHandler;
import org.springframework.beans.factory.annotation.Autowired;

public class DemoGlueJobHandler extends IJobHandler {
    @Autowired
    private HelloService helloService;
    @Override
    public void execute() throws Exception {
        helloService.methodA();
    }
}

（当上述都配置好后，点击调度中心的任务管理，选择这个glue任务，执行1次后，即可在执行器中查看到执行效果。代码会从调度中心发送到对应的执行器中去执行！适用于：项目已经部署上线了，但是需要临时加个定时任务）

启动并执行程序

2.6 执行器集群

2.6.1 集群环境搭建

在IDEA中设置SpringBoot项目运行开启多个集群

启动两个SpringBoot程序,需要修改Tomcat端口和执行器端口

• Tomcat端口8090程序的命令行参数如下:

  -Dserver.port=8090 -Dxxl.job.executor.port=9998
  

• Tomcat端口8090程序的命令行参数如下:

  -Dserver.port=8091 -Dxxl.job.executor.port=9999
  

（XxlJobDemoApplication按如上方法启动2次之后，可以在调度中心的执行器管理页面看到同1个AppName的执行器的online机器地址有2个http://127.0.0.1:9998/和http://127.0.0.1:9999/）

在任务管理中，修改路由策略，修改成轮询

重新启动,我们可以看到效果是,定时任务会在这两台机器中进行轮询的执行

• 8090端口的控制台日志如下:

  

• 8091端口的控制台日志如下:

  

2.6.2 调度路由算法讲解

当执行器集群部署时，提供丰富的路由策略，包括:

1. FIRST（第一个）：固定选择第一个机器

2. LAST（最后一个）：固定选择最后一个机器；

3. ROUND（轮询）：依次的选择在线的机器发起调度

4. RANDOM（随机）：随机选择在线的机器；

5. CONSISTENT_HASH（一致性HASH）：

   每个任务按照Hash算法固定选择某一台机器，且所有任务均匀散列在不同机器上。

6. LEAST_FREQUENTLY_USED（最不经常使用）：使用频率最低的机器优先被选举；

7. LEAST_RECENTLY_USED（最近最久未使用）：最久未使用的机器优先被选举；

8. FAILOVER（故障转移）：按照顺序依次进行心跳检测，第一个心跳检测成功的机器选定为目标执行器并发起调度；

9. BUSYOVER（忙碌转移）：按照顺序依次进行空闲检测，第一个空闲检测成功的机器选定为目标执行器并发起调度；

10. SHARDING_BROADCAST(分片广播)：

    广播触发对应集群中所有机器执行一次任务，同时系统自动传递分片参数；可根据分片参数开发分片任务；

3. 分片功能讲解

3.1 案例需求讲解

需求:我们现在实现这样的需求，在指定节假日，需要给平台的所有用户去发送祝福的短信.

3.1.1 初始化数据

在数据库中导入xxl_job_demo.sql数据

/*
 Navicat Premium Data Transfer

 Source Server         : mysql5.7
 Source Server Type    : MySQL
 Source Server Version : 50740
 Source Host           : 192.168.202.200:3306
 Source Schema         : xxl_job_demo

 Target Server Type    : MySQL
 Target Server Version : 50740
 File Encoding         : 65001

 Date: 03/11/2022 08:43:35
*/

SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;

-- ----------------------------
-- Table structure for t_user_mobile_plan
-- ----------------------------
DROP TABLE IF EXISTS `t_user_mobile_plan`;
CREATE TABLE `t_user_mobile_plan`  (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `username` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  `nickname` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  `phone` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  `info` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 2001 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;

-- ----------------------------
-- Records of t_user_mobile_plan
-- ----------------------------
INSERT INTO `t_user_mobile_plan` VALUES (1, '张三1', '昵称1', '13000000001', '这个家伙很懒，什么都没留下');
INSERT INTO `t_user_mobile_plan` VALUES (2, '张三2', '昵称2', '13000000002', '这个家伙很懒，什么都没留下');
INSERT INTO `t_user_mobile_plan` VALUES (3, '张三3', '昵称3', '13000000003', '这个家伙很懒，什么都没留下');
INSERT INTO `t_user_mobile_plan` VALUES (4, '张三4', '昵称4', '13000000004', '这个家伙很懒，什么都没留下');
INSERT INTO `t_user_mobile_plan` VALUES (5, '张三5', '昵称5', '13000000005', '这个家伙很懒，什么都没留下');
INSERT INTO `t_user_mobile_plan` VALUES (6, '张三6', '昵称6', '13000000006', '这个家伙很懒，什么都没留下');
INSERT INTO `t_user_mobile_plan` VALUES (7, '张三7', '昵称7', '13000000007', '这个家伙很懒，什么都没留下');
INSERT INTO `t_user_mobile_plan` VALUES (8, '张三8', '昵称8', '13000000008', '这个家伙很懒，什么都没留下');
INSERT INTO `t_user_mobile_plan` VALUES (9, '张三9', '昵称9', '13000000009', '这个家伙很懒，什么都没留下');
INSERT INTO `t_user_mobile_plan` VALUES (10, '张三10', '昵称10', '13000000010', '这个家伙很懒，什么都没留下');
INSERT INTO `t_user_mobile_plan` VALUES (11, '张三11', '昵称11', '13000000011', '这个家伙很懒，什么都没留下');
INSERT INTO `t_user_mobile_plan` VALUES (12, '张三12', '昵称12', '13000000012', '这个家伙很懒，什么都没留下');
INSERT INTO `t_user_mobile_plan` VALUES (13, '张三13', '昵称13', '13000000013', '这个家伙很懒，什么都没留下');
INSERT INTO `t_user_mobile_plan` VALUES (14, '张三14', '昵称14', '13000000014', '这个家伙很懒，什么都没留下');
INSERT INTO `t_user_mobile_plan` VALUES (15, '张三15', '昵称15', '13000000015', '这个家伙很懒，什么都没留下');
INSERT INTO `t_user_mobile_plan` VALUES (16, '张三16', '昵称16', '13000000016', '这个家伙很懒，什么都没留下');
INSERT INTO `t_user_mobile_plan` VALUES (17, '张三17', '昵称17', '13000000017', '这个家伙很懒，什么都没留下');
INSERT INTO `t_user_mobile_plan` VALUES (18, '张三18', '昵称18', '13000000018', '这个家伙很懒，什么都没留下');
INSERT INTO `t_user_mobile_plan` VALUES (19, '张三19', '昵称19', '13000000019', '这个家伙很懒，什么都没留下');
INSERT INTO `t_user_mobile_plan` VALUES (20, '张三20', '昵称20', '13000000020', '这个家伙很懒，什么都没留下');
INSERT INTO `t_user_mobile_plan` VALUES (21, '张三21', '昵称21', '13000000021', '这个家伙很懒，什么都没留下');
INSERT INTO `t_user_mobile_plan` VALUES (22, '张三22', '昵称22', '13000000022', '这个家伙很懒，什么都没留下');
INSERT INTO `t_user_mobile_plan` VALUES (23, '张三23', '昵称23', '13000000023', '这个家伙很懒，什么都没留下');
INSERT INTO `t_user_mobile_plan` VALUES (24, '张三24', '昵称24', '13000000024', '这个家伙很懒，什么都没留下');
INSERT INTO `t_user_mobile_plan` VALUES (25, '张三25', '昵称25', '13000000025', '这个家伙很懒，什么都没留下');
INSERT INTO `t_user_mobile_plan` VALUES (26, '张三26', '昵称26', '13000000026', '这个家伙很懒，什么都没留下');
INSERT INTO `t_user_mobile_plan` VALUES (27, '张三27', '昵称27', '13000000027', '这个家伙很懒，什么都没留下');
INSERT INTO `t_user_mobile_plan` VALUES (28, '张三28', '昵称28', '13000000028', '这个家伙很懒，什么都没留下');
INSERT INTO `t_user_mobile_plan` VALUES (29, '张三29', '昵称29', '13000000029', '这个家伙很懒，什么都没留下');
INSERT INTO `t_user_mobile_plan` VALUES (30, '张三30', '昵称30', '13000000030', '这个家伙很懒，什么都没留下');
INSERT INTO `t_user_mobile_plan` VALUES (31, '张三31', '昵称31', '13000000031', '这个家伙很懒，什么都没留下');
INSERT INTO `t_user_mobile_plan` VALUES (32, '张三32', '昵称32', '13000000032', '这个家伙很懒，什么都没留下');
INSERT INTO `t_user_mobile_plan` VALUES (33, '张三33', '昵称33', '13000000033', '这个家伙很懒，什么都没留下');
INSERT INTO `t_user_mobile_plan` VALUES (34, '张三34', '昵称34', '13000000034', '这个家伙很懒，什么都没留下');
INSERT INTO `t_user_mobile_plan` VALUES (35, '张三35', '昵称35', '13000000035', '这个家伙很懒，什么都没留下');
INSERT INTO `t_user_mobile_plan` VALUES (36, '张三36', '昵称36', '13000000036', '这个家伙很懒，什么都没留下');
INSERT INTO `t_user_mobile_plan` VALUES (37, '张三37', '昵称37', '13000000037', '这个家伙很懒，什么都没留下');
INSERT INTO `t_user_mobile_plan` VALUES (38, '张三38', '昵称38', '13000000038', '这个家伙很懒，什么都没留下');
INSERT INTO `t_user_mobile_plan` VALUES (39, '张三39', '昵称39', '13000000039', '这个家伙很懒，什么都没留下');
INSERT INTO `t_user_mobile_plan` VALUES (40, '张三40', '昵称40', '13000000040', '这个家伙很懒，什么都没留下');
INSERT INTO `t_user_mobile_plan` VALUES (41, '张三41', '昵称41', '13000000041', '这个家伙很懒，什么都没留下');
INSERT INTO `t_user_mobile_plan` VALUES (42, '张三42', '昵称42', '13000000042', '这个家伙很懒，什么都没留下');
INSERT INTO `t_user_mobile_plan` VALUES (43, '张三43', '昵称43', '13000000043', '这个家伙很懒，什么都没留下');
INSERT INTO `t_user_mobile_plan` VALUES (44, '张三44', '昵称44', '13000000044', '这个家伙很懒，什么都没留下');
INSERT INTO `t_user_mobile_plan` VALUES (45, '张三45', '昵称45', '13000000045', '这个家伙很懒，什么都没留下');
INSERT INTO `t_user_mobile_plan` VALUES (46, '张三46', '昵称46', '13000000046', '这个家伙很懒，什么都没留下');
INSERT INTO `t_user_mobile_plan` VALUES (47, '张三47', '昵称47', '13000000047', '这个家伙很懒，什么都没留下');
INSERT INTO `t_user_mobile_plan` VALUES (48, '张三48', '昵称48', '13000000048', '这个家伙很懒，什么都没留下');
INSERT INTO `t_user_mobile_plan` VALUES (49, '张三49', '昵称49', '13000000049', '这个家伙很懒，什么都没留下');
INSERT INTO `t_user_mobile_plan` VALUES (50, '张三50', '昵称50', '13000000050', '这个家伙很懒，什么都没留下');
...
INSERT INTO `t_user_mobile_plan` VALUES (2000, '张三2000', '昵称2000', '13000002000', '这个家伙很懒，什么都没留下');

-- ----------------------------
-- Procedure structure for multiInsertM
-- ----------------------------
DROP PROCEDURE IF EXISTS `multiInsertM`;
delimiter ;;
CREATE PROCEDURE `multiInsertM`(IN args INT)
BEGIN
	DECLARE
		i INT DEFAULT 1;
	START TRANSACTION;#开启事务
	WHILE
			i <= args DO
			INSERT INTO t_user_mobile_plan (username, nickname, phone,info)
		VALUES
			(
				concat("张三",i),
				concat("昵称",i),
				13000000000+i,
				"这个家伙很懒，什么都没留下");
		
		SET i = i + 1;
	END WHILE;
	COMMIT;

END
;;
delimiter ;

SET FOREIGN_KEY_CHECKS = 1;

3.1.2 集成Druid&MyBatis

添加依赖

<!--MyBatis驱动-->
<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>1.2.0</version>
</dependency>
<!--mysql驱动-->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
</dependency>
<!--lombok依赖-->
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <scope>provided</scope>
</dependency>
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.10</version>
</dependency>

添加配置

spring.datasource.url=jdbc:mysql://localhost:3306/xxl_job_demo?serverTimezone=GMT%2B8&useUnicode=true&characterEncoding=UTF-8
spring.datasource.driverClassName=com.mysql.jdbc.Driver
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
spring.datasource.username=root
spring.datasource.password=WolfCode_2017

添加实体类

@Setter@Getter
public class UserMobilePlan {
    private Long id;//主键
    private String username;//用户名
    private String nickname;//昵称
    private String phone;//手机号码
    private String info;//备注
}

添加Mapper处理类

@Mapper
public interface UserMobilePlanMapper {
    @Select("select * from t_user_mobile_plan")
    List<UserMobilePlan> selectAll();
}

3.1.3 业务功能实现

任务处理方法实现

@XxlJob("sendMsgHandler")
public void sendMsgHandler() throws Exception{
    List<UserMobilePlan> userMobilePlans = userMobilePlanMapper.selectAll();
    System.out.println("任务开始时间:"+new Date()+",处理任务数量:"+userMobilePlans.size());
    Long startTime = System.currentTimeMillis();
    userMobilePlans.forEach(item->{
        try {
            //模拟发送短信动作
            TimeUnit.MILLISECONDS.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    });
    System.out.println("任务结束时间:"+new Date());
    System.out.println("任务耗时:"+(System.currentTimeMillis()-startTime)+"毫秒");
}

任务配置信息

3.2 分片概念讲解

比如我们的案例中有2000+条数据，如果不采取分片形式的话，任务只会在一台机器上执行，这样的话需要20+秒才能执行完任务.

如果采取分片广播的形式的话，一次任务调度将会广播触发对应集群中所有执行器执行一次任务，同时系统自动传递分片参数；可根据分片参数开发分片任务；

获取分片参数方式:

// 可参考Sample示例执行器中的示例任务"ShardingJobHandler"了解试用 
int shardIndex = XxlJobHelper.getShardIndex();
int shardTotal = XxlJobHelper.getShardTotal();

通过这两个参数，我们可以通过求模取余的方式，分别查询，分别执行，这样的话就可以提高处理的速度.

之前2000+条数据只在一台机器上执行需要20+秒才能完成任务，分片后，有两台机器可以共同完成2000+条数据，每台机器处理1000+条数据，这样的话只需要10+秒就能完成任务

3.3 案例改造成任务分片

Mapper增加查询方法

@Mapper
public interface UserMobilePlanMapper {
    @Select("select * from t_user_mobile_plan where mod(id,#{shardingTotal})=#{shardingIndex}")
    List<UserMobilePlan> selectByMod(@Param("shardingIndex") Integer shardingIndex,@Param("shardingTotal")Integer shardingTotal);
    @Select("select * from t_user_mobile_plan")
    List<UserMobilePlan> selectAll();
}

任务类方法

（要利用分片总数和分片索引，拆分任务到具体的执行器上）

@XxlJob("sendMsgShardingHandler")
public void sendMsgShardingHandler() throws Exception{
    System.out.println("任务开始时间:"+new Date());
    int shardTotal = XxlJobHelper.getShardTotal();
    int shardIndex = XxlJobHelper.getShardIndex();
    List<UserMobilePlan> userMobilePlans = null;
    if(shardTotal==1){
        //如果没有分片就直接查询所有数据
        userMobilePlans = userMobilePlanMapper.selectAll();
    }else{
        userMobilePlans = userMobilePlanMapper.selectByMod(shardIndex,shardTotal);
    }
    System.out.println("处理任务数量:"+userMobilePlans.size());
    Long startTime = System.currentTimeMillis();
    userMobilePlans.forEach(item->{
        try {
            TimeUnit.MILLISECONDS.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    });
    System.out.println("任务结束时间:"+new Date());
    System.out.println("任务耗时:"+(System.currentTimeMillis()-startTime)+"毫秒");
}

任务设置

（注意，一定要选择分片广播的路由策略）

4. 用法说明和总结

@Slf4j
@Component
public class LogXxlJob {

    /*
      xxl-job设计原理
        - 将调度行为抽象形成“调度中心”公共平台，而平台自身并不承担业务逻辑，
          “调度中心”负责发起调度请求。将任务抽象成分散的JobHandler，交由“执行器”统一管理，
          “执行器”负责接收调度请求并执行对应的JobHandler中业务逻辑。
          因此，“调度”和“任务”两部分可以相互解耦，提高系统整体稳定性和扩展性；
        - 调度采用线程池方式实现，避免单线程因阻塞而引起任务调度延迟
        - 全异步化设计
            - 异步调度：调度中心每次任务触发时仅发送一次调度请求，该调度请求首先推送“异步调度队列”，然后异步推送给远程执行器
            - 异步执行：执行器会将请求存入“异步执行队列”并且立即响应调度中心，异步运行。
        - 一次完整的任务调度通讯流程
            - 1、“调度中心”向“执行器”发送http调度请求: “执行器”中接收请求的服务，实际上是一台内嵌Server，默认端口9999;
            - 2、“执行器”执行任务逻辑；
            - 3、“执行器”http回调“调度中心”调度结果: “调度中心”中接收回调的服务，是针对执行器开放一套API服务;

      调度中心如何实现集群
        - 只需要连接同1个数据库的xxl-job的表即可
          XXL-JOB 默认使用单点数据库，但在生产环境下，可以通过主从复制、高可用数据库集群或数据库中间件来提升数据库的容错能力，从而实现高可用部署。
        - 基于数据库的集群方案，数据库选用Mysql；
          集群分布式并发环境中进行定时任务调度时，会在各个节点会上报任务，存到数据库中，执行时会从数据库中取出触发器来执行，
          如果触发器的名称和执行时间相同，则只有一个节点去执行此任务。

      执行器如何实现集群
        - 进入调度中心的执行器管理页面，新建执行器，填写AppName和名称。
          注册方式选择自动注册

      调度中心需要和执行器设置相同的accessToken才能通信

      定义任务的方式
        - Bean模式(方法形式)
            - 在执行器中，定义spring Bean，在该bean内，使用@XxlJob("jobHandlerName")注解标注方法成为1个任务，
              在调度中心的任务管理页面，新增任务，选择任务所在的执行器，填写@XxlJob注解中填写的jobHandlerName，
            - 在@XxlJob注解中，使用init定义初始化方法，使用destroy定义销毁方法，它们针对的是JobThread这个线程
            - 通过这几个方法定义任务执行结果，然后返回给调度中心（查看 JobThread 类详情即可）。
                 - XxlJobHelper.handleSuccess 200
                 - XxlJobHelper.handleFail    500
                 - XxlJobHelper.handleTimeout 502
                 - XxlJobHelper.handleResult  自定义状态码
              当不调用XxlJobHelper.handleXXX时, 默认就是200
              抛异常时，状态码500
              手动终止任务时，状态码500

        - Bean模式(类形式)
            - 在执行器中，定义1个spring Bean，该bean要实现IJobHandler接口，
              并且实现InitializingBean接口，在重写的afterPropertiesSet中调用XxlJobExecutor.registJobHandler("myJobHandler", this);注册进去，
              调度中心的任务管理页面，新增任务，选择任务所在的执行器，填写myJobHandler节定义1个任务，
              剩下的与上面完全一致


        - GLUE模式(Java)
            - 原理：每个 “GLUE模式(Java)” 任务的代码，实际上是“一个继承自“IJobHandler”的实现类的类代码”，
                   “执行器”接收到“调度中心”的调度请求时，会通过Groovy类加载器加载此代码，实例化成Java对象，
                   同时注入此代码中声明的Spring服务（请确保Glue代码中的服务和类引用在“执行器”项目中存在），
                   然后调用该对象的execute方法，执行任务逻辑。

        - GLUE模式(Shell/python)
            - 原理：脚本任务的源码托管在调度中心，脚本逻辑在执行器运行。当触发脚本任务时，
                   执行器会加载脚本源码在执行器机器上生成一份脚本文件，然后通过Java代码调用该脚本；
                   并且实时将脚本输出日志写到任务日志文件中，从而在调度中心可以实时监控脚本运行情况；
            - 支持的脚本:
                - shell脚本
                - python脚本
                - php脚本
                - nodejs脚本
                - powershell脚本
            - 脚本任务通过 Exit Code 判断任务执行结果

      获取任务参数
        - String jobParam = XxlJobHelper.getJobParam()

      输出日志方法
          - XxlJobHelper.log("testLog Start..., jobParam: {}", jobParam);
          - 使用XxlJobHelper.log记录的日志可以在执行日志中实时看到日志输出内容
          - 使用log.info()不会记录到查看的执行日志中
          - 日志文件存放的位置可在“执行器”配置文件进行自定义，默认目录格式为：/data/applogs/xxl-job/jobhandler/“格式化日期”/“数据库调度日志记录的主键ID.log”
          - 在JobHandler中开启子线程时，子线程将会把日志打印在父线程即JobHandler的执行日志中，方便日志追踪。

      任务失败告警
        - 任务执行失败时，默认会发送告警邮件
            - 配置如下即可:
                spring.mail.host=smtp.qq.com
                spring.mail.port=587
                spring.mail.username=1255112011@qq.com
                spring.mail.from=1255112011@qq.com
                spring.mail.password=lpdlufuvmagnbafc
                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
            - 创建任务时，可添加多个报警邮箱
            - 默认实现是EmailJobAlarm，可自定义实现JobAlarm接口，因为JobAlarmer中会自动注入容器中的所有JobAlarm接口实例Bean
        - 认定为任务执行失败的情况有
            - 任务执行超时
            - 任务抛出异常
            - 任务通过XxlJobHelper.handleFail标记为失败

      并行调度
        - XXL-JOB调度模块默认采用并行机制，在多线程调度的情况下，调度模块被阻塞的几率很低，大大提高了调度系统的承载量。
        - XXL-JOB的不同任务之间并行调度、并行执行。
        - XXL-JOB的单个任务，针对多个执行器是并行运行的，针对单个执行器是串行执行的。同时支持任务终止。


      路由策略
        - 取值
            - 第一个
            - 最后一个
            - 轮询
            - 随机一致性
            - HASH
            - 最不经常使用
            - 最近最久未使用
            - 故障转移
            - 忙碌转移
            - 分片广播
        - 执行器集群部署时提供丰富的路由策略
        - 当执行器集群部署时，任务需要在其中1个执行器上执行，以避免任务被多个机器同时执行
        - 分片广播，广播触发对应集群中所有机器执行一次任务，同时系统自动传递分片参数。
        - 故障转移，当第一个执行器失败时，依次尝试下一个执行器，直到找到可用的执行器。
        - 忙碌转移，当第一个执行器忙碌时，依次尝试下一个执行器，直到找到空闲的执行器。

      调度过期策略
        - 取值
            - 忽略
            - 立即触发一次
        - 调度中心错过调度时间的补偿处理策略
            - 忽略：调度过期后，忽略过期的任务，从当前时间开始重新计算下次触发时间；
            - 立即执行一次：调度过期后，立即执行一次，并从当前时间开始重新计算下次触发时间；
        - 可能原因：服务重启；调度线程被阻塞，线程被耗尽；上次调度持续阻塞，下次调度被错过；
        - MisfireStrategyEnum


      阻塞处理策略
        - 取值
            - 单机串行
            - 丢弃后续调度
            - 覆盖之前调度
        - 调度过于密集执行器来不及处理时的处理策略
            - 单机串行（默认）：调度请求进入单机执行器后，调度请求进入FIFO队列并以串行方式运行；
            - 丢弃后续调度   ：调度请求进入单机执行器后，发现执行器存在运行的调度任务，本次请求将会被丢弃并标记为失败；
            - 覆盖之前调度   ：调度请求进入单机执行器后，发现执行器存在运行的调度任务，将会终止运行中的调度任务并清空队列，然后运行本地调度任务；
        - ExecutorBlockStrategyEnum

      任务超时时间
        - 支持自定义任务超时时间，任务运行超时将会主动中断任务
        - 如果在新建任务时，设置了任务超时时间，在JobThread中会创建1个新的线程使用FutureTask去完成任务，
          并设置超时时间，并且在finally中会调用该线程的interrupt方法去中断该线程

      失败重试次数
        - 当任务失败时将会按照预设的失败重试次数主动进行重试
        - 其中分片任务支持分片粒度的失败重试；

      子任务ID
        - 当父任务执行结束且执行成功后将会主动触发一次子任务的执行, 多个子任务用逗号分隔

      灰度上线
        - 步骤
            - 1、执行器改为手动注册，下线一半机器列表（A组），线上运行另一半机器列表（B组）；
            - 2、等待A组机器任务运行结束并编译上线；执行器注册地址替换为A组；
            - 3、等待B组机器任务运行结束并编译上线；执行器注册地址替换为A组+B组；
            - 4、操作结束；

     */
    @XxlJob(value = "testLog", init = "doInit", destroy = "doDestroy")
    public void testLog() throws Exception {

        // 获取传递的参数
        String jobParam = XxlJobHelper.getJobParam();

        log.info("打印日志了~~START, jobParam: {}", jobParam);

        // 只有通过 XxlJobHelper.log() 才会记录日志到 查看的执行日志中
        // （日志默认保存在/data/applogs/xxl-job/jobhandler文件夹中）
        XxlJobHelper.log("testLog Start..., jobParam: {}", jobParam);

        Integer count = null;
        try {
            count = Integer.valueOf(!StringUtils.hasText(jobParam ) ? "10" : jobParam);
        } catch (Exception e) {
            XxlJobHelper.log("testLog 任务执行参数解析发生错误:{}", e.getMessage());
            // 调用 XxlJobHelper.handleFail()时
            XxlJobHelper.handleFail("任务执行参数解析发生错误了...");
            return;
        }

        // 当不调用 XxlJobHelper.handleXXX时
        if (count == 0) {
            log.info("count为0");
            XxlJobHelper.log("testLog count为0:{}", "count为0");
            return;
        }

        // 当未调用XxlJobHelper.handleXXX，抛异常时
        if (count == 10) {
            log.info("count不能为10...1");
            XxlJobHelper.log("testLog 失败日志:{}", "count不能为10...2");
            throw new RuntimeException("count不能为10");
        }

        // 模拟中断
        // （当手动终止任务时，此处的sleep会抛出中断异常，在JobThread中会被捕捉到，标记位处理失败）
        for (int i = 0; i < count; i++) {
            XxlJobHelper.log("testLog 进入sleep:{}", i);
            log.info("进入sleep: {}", i);
            TimeUnit.SECONDS.sleep(1);
        }

        XxlJobHelper.log("testLog End...");

        log.info("打印日志了~~END");

    }

    public void doInit() {
        log.info("doInit...");
    }

    public void doDestroy() {
        log.info("doDestroy...");
    }

}

5. xxl_job数据库中八张表的作用

表名	作用
xxl_job_info	存储任务的基本信息，如任务名称、执行器信息、调度规则等。
xxl_job_log	存储任务的执行日志，包括任务执行状态、执行耗时、执行结果等。
xxl_job_logglue	存储任务的 Glue 配置信息，如 Glue 类型、Glue 源码等。
xxl_job_trigger_log	存储任务的触发日志，包括任务触发时间、触发结果等。
xxl_job_user	存储用户信息，如用户名、密码、角色等。
xxl_job_group	存储执行器分组信息，如执行器分组名称、执行器信息等。
xxl_job_registry	存储执行器的注册信息，如执行器 IP、端口、心跳间隔等。
xxl_job_lock	存储任务执行时的锁信息，以避免任务并发执行。