关于java:xxljob-Vs-ElasticJob谁牛

@[toc]
前两天写了一篇文章介绍了一下 ElasticJob，有不少小伙伴强烈建议讲讲 xxl-job，其实 ElasticJob 原本就是一个引子，松哥原本就是想和大家分享 xxl-job 的（手动狗头。

松哥也在微信群里和小伙伴们探讨过各自到底用的是 xxl-job 还是 ElasticJob，探讨的后果就是，xxl-job 应用的人更多一些。

不说性能的优劣，咱们单纯从数据上其实就能看出一些端倪：

这是 xxl-job 的 GitHub：

这是 ElasticJob 的 GitHub：

从这个数据比拟上大略也能看进去 xxl-job 更火一些。留神我这里说的是更火一些，不是说 xxl-job 比 ElasticJob 更强。

xxl-job 出自公众点评，这是一个分布式轻量级的任务调度框架，其外围设计指标是开发迅速、学习简略、轻量级、易扩大。

xxl-job 通过一个核心式的调度平台，调度多个执行器执行工作，调度核心通过 DB 锁保障集群散布式调度的一致性，这样扩大执行器会增大 DB 的压力，然而大部分公司的工作数，执行器并不多；xxl-job 提供了十分好用的监控页面甚至还有工作失败的邮件告警性能。不同于 ElasticJob，xxl-job 在应用时依赖 MySQL，而不须要 ZooKeeper。

ElasticJob 则出自当当，设计 ElasticJob 的初衷是为了面对高并发以及简单的业务，即便是在业务量大，服务器多的时候也能做好任务调度，尽可能的利用服务器的资源。ElasticJob 是无中心化的，如果主服务器挂了，会主动通过 ZooKeeper 的选举机制选举出新的主服务器。因而 ElasticJob 具备良好的扩展性和可用性。

所以，你打算用哪个？

咱们先把 xxl-job 跑起来，再写咱们本人的代码。

首先咱们先把 xxl-job 的代码搞下来，地址：

https://github.com/xuxueli/xx…

而后用 IDEA 关上我的项目，关上之后，有四个次要的文件夹：

doc：我的项目文档
xxl-job-admin：任务调度平台
xxl-job-core：外围代码
xxl-job-executor-samples：案例

因为 xxl-job 运行须要数据库，所以接下来咱们就来配置数据库，先找到数据库脚本，在 doc/db/tables_xxl_job.sql 地位。

找到数据库脚本后，导入到数据库中执行一下，执行实现后，生成如下库和表：

接下来找到 xxl-job-admin/src/main/resources/application.properties 文件，批改数据库连贯信息：

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=123
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

日志配置也要批改一下，在 xxl-job-admin/src/main/resources/logback.xml 文件中，有如下一行：

<property name="log.path" value="/data/applogs/xxl-job/xxl-job-admin.log"/>

如果你是 Windows 操作系统，这里必定要改，如果你是 Mac 的话，也有可能没有这个目录的权限，因而我倡议大家改一下这里的配置，改为如下这样：

<property name="log.path" value="./applogs/xxl-job/xxl-job-admin.log"/>

改为在我的项目运行目录下生成这个日志文件。

批改实现后，接下来咱们就能够启动 xxl-job-admin 我的项目了，这是一个 SpringBoot 我的项目，找到启动类，间接运行其 main 办法即可。

我的项目启动胜利后，浏览器输出如下地址 http://localhost:8080/xxl-job-admin/toLogin，就能够看到登录页面了：

默认的登录账号是 admin/123456。

看到如下页面，就是登录胜利了。

接下来咱们来创立一个我的项目，跑一个定时工作看看。

首先创立一个 SpringBoot 我的项目，引入 Web 依赖，如下：

我的项目创立胜利后，引入 xxl-job 的依赖：

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

而后在 resources 目录下退出 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="./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>

批改 application.properties 文件，内容如下：

# web port
server.port=8089

# 日志配置
logging.config=classpath:logback.xml

# 配置调度核心地址
xxl.job.admin.addresses=http://127.0.0.1:8080/xxl-job-admin

# 执行器和调度核心之间的通信令牌，如果没有配置，示意敞开了通信令牌的校验。# 在 xxl-job-admin 的配置文件中，有一个截然不同的配置项，两边都配置，就会进行校验。xxl.job.accessToken=

# 配置执行器的名字
xxl.job.executor.appname=xxl-job-demo
# 执行器地址，如果没有配置，就应用 IP:PORT 作为默认值
xxl.job.executor.address=
# 执行器 ip 地址
xxl.job.executor.ip=
# 执行器端口，默认即 9999
xxl.job.executor.port=9999
# 执行器日志文件地位
xxl.job.executor.logpath=./applogs/xxl-job/jobhandler
# 执行器日志保留工夫
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;
    }

}

其实就是把刚刚 application.properties 中的属性都配置成一个 XxlJobSpringExecutor Bean，很奇怪官网为什么没把这个搞成一个自动化配置的 Bean。

接下来咱们就能够创立一个具体的定时工作了。

对于咱们 Java 工程师而言，有三种开发定时工作的形式。

Bean 模式工作，反对基于类的开发方式，每个工作对应一个 Java 类。

长处：不限度我的项目环境，兼容性好。即便是无框架我的项目，如 main 办法间接启动的我的项目也能够提供反对。

毛病：

每个工作须要占用一个 Java 类，造成类的节约；
不反对主动扫描工作并注入到执行器容器，须要手动注入。

开发方式：

开发一个继承自 com.xxl.job.core.handler.IJobHandler 的 JobHandler 类，实现其中工作办法。
手动通过如下形式注入到执行器容器：

XxlJobExecutor.registJobHandler("demoJobHandler", new DemoJobHandler());

在调度核心新建调度工作（后续步骤和 3.2.1 BEAN 模式（办法模式） 统一）。

这种形式用的不多，我就不给大家演示了，小伙伴们能够自行尝试。

Bean 模式工作，反对基于办法的开发方式，每个工作对应一个办法，个别举荐这种形式。

长处：

每个工作只须要开发一个办法，并增加”@XxlJob”注解即可，更加不便、疾速。
反对主动扫描工作并注入到执行器容器。

毛病：

要求 Spring 容器环境。

基于办法开发的工作，底层会生成 JobHandler 代理，和基于类的形式一样，工作也会以 JobHandler 的模式存在于执行器工作容器中。

开发步骤：

开发 Job 办法：

@Component
public class MyJob {@XxlJob("demoJobHandler")
    public ReturnT<String> demoJobHandler() throws Exception {String param = XxlJobHelper.getJobParam();
        XxlJobHelper.log("XXL-JOB, Hello World：{}",param);
        return ReturnT.SUCCESS;
    }
}

这里的 @XxlJob 注解标记了这是一个定时工作办法，该注解还有 init 和 destroy 属性，能够别离用来配置初始化和销毁的办法。

XxlJobHelper.getJobParam() 能够用来获取工作参数。

在这个过程中，咱们须要通过 XxlJobHelper.log 打印执行日志。

默认工作后果为 “ 胜利 ” 状态，不须要被动设置；如有诉求，比方设置工作后果为失败，能够通过 XxlJobHelper.handleFail/handleSuccess 自主设置工作后果。

而后启动 SpringBoot 我的项目。

配置调度核心，新建调度工作

接下来关上配置调度核心，找到执行器治理，点击新增，如下：

如果是主动注册的话，能够不必填机器地址。

接下来找到工作治理，并点击新增：

根底配置都没啥好说的。

调度类型抉择 CRON 表达式，CRON 表达式能够本人填，也能够点击前面的编辑按钮主动生成。

运行模式就抉择 BEAN，JobHandler 的值就是咱们后面 @XxlJob 注解中填的值，工作参数就是定时工作的办法参数。

配置实现后，回到执行器治理，点击查看，能够查看刚刚注册的节点信息：

再次回到工作治理，抉择启动，就能够开始定时工作的执行了：

开启之后，点击调度日志，就能够看到咱们零碎工作执行的详细信息了：

能够看到，每隔 5 秒执行一次。

点击调度备注，能够查看一些调度细节：

在左边操作按钮中抉择执行日志：

能够查看执行细节：

红色框出来的，就是咱们刚刚本人打印的。

当然这里还有一些其余玩法，小伙伴们能够自行点击按钮尝试，我就不赘述了。

工作以源码形式保护在调度核心，反对通过 Web IDE 在线更新，实时编译和失效，因而不须要指定 JobHandler。即在网页上写定时工作的代码，而后去执行。

这种形式个人感觉应用较少，小伙伴们理解一下即可。

开发流程如下：

调度核心 -> 工作治理，新建调度工作，新建时抉择“GLUE 模式 (Java)”：

开发工作代码：选中指定工作，点击该工作右侧 GLUE 按钮，将会返回 GLUE 工作的 Web IDE 界面，在该界面反对对工作代码进行开发（也能够在 IDE 中开发实现后，复制粘贴到编辑中）。

编辑实现后，保留即可。接下来又和后面一样了，启动工作，后查看调度日志。

这里反对 30 个版本的版本回溯，在 GLUE 工作的 Web IDE 界面，抉择右上角下拉框“版本回溯”，会列出该 GLUE 的更新历史，抉择相应版本即可显示该版本代码，保留后 GLUE 代码即回退到对应的历史版本。

好啦，这就是我跟大家介绍的 xxl-job，感兴趣的小伙伴能够试试哦～

公众号后盾回复 xxl-job-demo 能够下载本文案例。

关于java:xxljob-Vs-ElasticJob谁牛

1. xxl-job

2. 运行 xxl-job

3. 开发定时工作

3.1 我的项目创立及配置

3.2 定时工作开发方式

3.2.1 BEAN 模式（类模式）

3.2.2 BEAN 模式（办法模式）

3.2.3 GLUE 模式 (Java)

4. 小结

Just My Socks（注册教程内含优惠码）

关于java:xxljob-Vs-ElasticJob谁牛

1. xxl-job

2. 运行 xxl-job

3. 开发定时工作

3.1 我的项目创立及配置

3.2 定时工作开发方式

3.2.1 BEAN 模式（类模式）

3.2.2 BEAN 模式（办法模式）

3.2.3 GLUE 模式 (Java)

4. 小结

Just My Socks（注册教程 内含优惠码）

Just My Socks（注册教程内含优惠码）