02 xxljob快速入门

1 项目搭建

1. 新建一个maven父工程：pom文件中dependencyManagement声明依赖外部jar包的版本
   核心就是xxljob的jar：

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

完整内容如下：

<dependencyManagement>
   <dependencies>
       <dependency>
           <groupId>com.xuxueli</groupId>
           <artifactId>xxl-job-core</artifactId>
           <version>2.2.0</version>
       </dependency>
       <dependency>
           <groupId>org.projectlombok</groupId>
           <artifactId>lombok</artifactId>
           <version>1.18.16</version>
       </dependency>
       <dependency>
           <groupId>org.slf4j</groupId>
           <artifactId>slf4j-api</artifactId>
           <version>1.7.30</version>
       </dependency>
       <dependency>
           <groupId>ch.qos.logback</groupId>
           <artifactId>logback-classic</artifactId>
           <version>1.2.3</version>
       </dependency>
   </dependencies>
</dependencyManagement>
<build>
   <plugins>
       <plugin>
           <groupId>org.apache.maven.plugins</groupId>
           <artifactId>maven-compiler-plugin</artifactId>
           <version>3.8.1</version>
           <configuration>
               <target>1.8</target>
               <source>1.8</source>
           </configuration>
       </plugin>
   </plugins>
</build>

2 入门程序

新建一个子模块01-xxl-job-quickstart：通过一个简单的demo，体验一下xxljob的使用
本次用的版本是2.2.0

2.1 调度中心的部署

根据前面的介绍，xxljob是通过调度中心rpc调用执行器，执行任务的。首先部署调度中心

作用：统一管理任务调度平台上调度任务，负责触发调度执行，并且提供任务管理平台。

2.1.1 准备工作：下载源代码

1. 下载xxljob的源码，切换到对应版本的分支
   码云地址：http://www.51sjk.com/Upload/Articles/1/0/261/261998_20210702002046196.jpg
   github地址：https://github.com/xuxueli/xxl-job
2. 源码中的 xxl-job-admin模块就是调度中心，是一个springboot项目。

2.1.2 application.properties配置文件介绍和修改

xxl-job-admin模块就是调度中心，是一个springboot项目。简单介绍一下配置文件

### 调度中心JDBC链接：链接地址请保持和 2.1章节 所创建的调度数据库的地址一致
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.jdbc.Driver
###报警邮箱
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
###调度中心通讯TOKEN [选填]：非空时启用；
xxl.job.accessToken=
###调度中心国际化配置 [必填]： 默认为 "zh_CN"/中文简体, 可选范围为 "zh_CN"/中文简体, "zh_TC"/中文繁体 and "en"/英文；
xxl.job.i18n=zh_CN
##调度线程池最大线程配置【必填】
xxl.job.triggerpool.fast.max=200
xxl.job.triggerpool.slow.max=100
###调度中心日志表数据保存天数 [必填]：过期日志自动清理；限制大于等于7时生效，否则, 如-1，关闭自动清理功能；
xxl.job.logretentiondays=30

我们修改的主要就是一下几个：

• 端口号：默认是8080，可根据自己的喜好改自己的端口，这里我就改成1111
• 数据库链接地址：这里我就没做修改，数据库名字为：xxl_job
• 将数据库链接的用户名和密码改为自己的。

2.1.3 初始化调度中心数据库

1. 数据库脚本文件位置：/xxl-job/doc/db/tables_xxl_job.sql
2. 创建数据库，根据刚刚配置的数据库名字创建对应的数据库
3. 执行sql脚本

2.1.4 打包部署

1. mvn clean package
2. java -jar
3. 访问：http://localhost:1111/xxl-job-admin

默认用户名和密码：admin/123456

到此调度中心部署完成

可以刚刚的jar包保存，以后自己本地测试就可以使用这个jar包，直接java -jar运行

2.2 创建执行器

下面就是在调度中心创建执行器

1. 打开执行器管理、
   
2. 新增执行器
   

2.3 job开发

2.3.1 API介绍

1. 抽象类：com.xxl.job.core.handler.IJobHandler
   所有的job需要继承该抽象基类，实现其抽象方法execute

public abstract class IJobHandler {


	/** success */
	public static final ReturnT<String> SUCCESS = new ReturnT<String>(200, null);
	/** fail */
	public static final ReturnT<String> FAIL = new ReturnT<String>(500, null);
	/** fail timeout */
	public static final ReturnT<String> FAIL_TIMEOUT = new ReturnT<String>(502, null);

	/**
	 * execute handler, invoked when executor receives a scheduling request
	 *
	 * @param param
	 * @return
	 * @throws Exception
	 */
	public abstract ReturnT<String> execute(String param) throws Exception;
	/**
	 * init handler, invoked when JobThread init
	 */
	public void init() throws InvocationTargetException, IllegalAccessException {
		// do something
	}
	/**
	 * destroy handler, invoked when JobThread destroy
	 */
	public void destroy() throws InvocationTargetException, IllegalAccessException {
		// do something
	}
}

2.3.2 定义一个demoJob继承IJobHandler

package study.wyy.job.xxl.task;

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;

/**
 * @author wyaoyoa
 * @description
 * @date 2021/1/4 15:07
 */

public class DemoJob extends IJobHandler {
    public ReturnT<String> execute(String param) throws Exception {
        // 执行日志：需要通过 "XxlJobLogger.log" 打印执行日志
        XxlJobLogger.log("demo job start.... param is: "+param);
        TimeUnit.SECONDS.sleep(5);
        XxlJobLogger.log("demo job end.... param is: "+param);
        return ReturnT.SUCCESS;
    }
}

2.3.3注册任务到执行器

package study.wyy.job.xxl.config;


import com.xxl.job.core.executor.XxlJobExecutor;
import lombok.extern.slf4j.Slf4j;
import study.wyy.job.xxl.task.DemoJob;

/**
 * @author wyaoyao
 * @description
 * @date 2021/1/4 15:23
 * 配置job
 */
@Slf4j
public class XxlJobConfig {

    XxlJobExecutor xxlJobExecutor;

    // 配置job的执行器：
    public void initXxlJobExecutor(){
        // 注册任务，这里的key后面会用到
        XxlJobExecutor.registJobHandler("demoJob",new DemoJob());
        xxlJobExecutor = new XxlJobExecutor();

        // 设置调度中心地址
        xxlJobExecutor.setAdminAddresses("http://localhost:1111/xxl-job-admin");
        // 设置应用名字
        xxlJobExecutor.setAppname("xxl-job-quickstart");
        // 设置执行器的端口和ip 可以不指定，调度中心可以自动发现ip
        //xxlJobExecutor.setIp("127.0.0.1");
        xxlJobExecutor.setPort(9999);
        //xxlJobExecutor.setAddress("http://localhost:9999");
        // 执行器运行日志文件存储磁盘路径 [选填]
        xxlJobExecutor.setLogPath("D:\\log\\xxljob\\executor");
        // 执行器日志文件保存天数 [选填] ： 过期日志自动清理, 限制值大于等于3时生效; 否则, 如-1, 关闭自动清理功能；
        xxlJobExecutor.setLogRetentionDays(4);
        // 启动执行器
        try {
            xxlJobExecutor.start();
        } catch (Exception e) {
            log.error(e.getMessage(),e);
            e.printStackTrace();
        }
    }

	// 当我们的程序结束的时候需要销毁执行器
    public void destroy(){
        if (xxlJobExecutor != null) {
            xxlJobExecutor.destroy();
        }
    }
}

2.3.4启动类

package study.wyy.job.xxl;

import com.xxl.job.core.executor.XxlJobExecutor;
import lombok.extern.slf4j.Slf4j;
import study.wyy.job.xxl.config.XxlJobConfig;

import java.util.concurrent.TimeUnit;

/**
 * @author wyaoyao
 * @description
 * @date 2021/1/4 16:02
 */
@Slf4j
public class Client {

    public static void main(String[] args) {
        XxlJobConfig xxlJobConfig = new XxlJobConfig();
        try {
       		// 配置执行器，并启动
            xxlJobConfig.initXxlJobExecutor();
            while (true) {
                TimeUnit.HOURS.sleep(1);
            }
        }catch (Exception e){
            log.error(e.getMessage(),e);
        }finally {
            xxlJobConfig.destroy();
        }
    }
}

2.3 调度中心新建任务

这里配置的任务参数会被传递到execute方法的形参中，是字符串类型

2.4 测试

1. 启动启动类
2. 调度中心启动任务
   
3. 观察执行日志
   

2.5 总结

2.5.1 开发步骤

开发来说还是比较麻烦的，不是很喜欢，哈哈哈，

1. 部署调度中心服务
2. 创建执行器
3. 开发任务
4. 向执行器中注册任务，配置执行器的一些基本配置信息
   • 执行器的ip和端口：观察启动日志，可以发现，xxljob会启动一个netty服务
   • 设置调度中心的地址
   • 设置应用的名字
   • 设置日志相关配置：日志保存路径和日志保存时间
5. 调度中心中选择执行器并创建任务，配置任务的基本信息
   • cron表达式
   • 任务的模式：bean模式和glue模式（入门程序演示的是bean模式）
   • 任务的超时时间，参数，路由策略等等
6. 启动我们的程序之后，再去调度中心启动任务

启动日志中，netty服务的启动

xxljob也依赖了netty，xxl应该是会将执行器作为一个netty服务，调度中心通过rpc远程调用执行器，触发任务。

2.5.2 xxl的job模式

• BEAN模式（类形式）
  Bean模式任务，支持基于类的开发方式，每个任务对应一个Java类。刚刚的入门程序便是采用的这个模式
  优点：不限制项目环境，兼容性好。即使是无框架项目，如main方法直接启动的项目也可以提供支持
  缺点：每个任务需要占用一个Java类，造成类的浪费；不支持自动扫描任务并注入到执行器容器，需要手动注入。

• BEAN模式（方法形式）
  Bean模式任务，支持基于方法的开发方式，每个任务对应一个方法。
  优点：每个任务只需要开发一个方法，并添加”@XxlJob”注解即可，更加方便、快速。
  支持自动扫描任务并注入到执行器容器。
  缺点：要求Spring容器环境；

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