XXL-JOB es una plataforma de programación de tareas distribuidas . Sus principales objetivos de diseño son el desarrollo rápido, el aprendizaje fácil, el peso ligero y la expansión fácil. El código fuente ahora está abierto y conectado a las líneas de productos en línea de muchas empresas, listos para usar.

xxl es el comienzo pinyin del nombre [Xu Xueli] de Dianping, el desarrollador de xxl-job

Dirección del sitio web oficial

Plataforma de programación de tareas distribuidas XXL-JOB

dirección del documento

Dirección del almacén del código fuente

Dirección del almacén del código fuente	Descarga de lanzamiento
GitHub - xuxueli/xxl-job: un marco de programación de tareas distribuidas (plataforma de programación de tareas distribuidas XXL-JOB)	Descargar
xxl-job: una plataforma de programación de tareas distribuidas, sus objetivos principales de diseño son el desarrollo rápido, el aprendizaje fácil, el peso ligero y la expansión fácil. El código fuente ahora está abierto y conectado a las líneas de productos en línea de muchas empresas, listos para usar.	Descargar

Dirección del almacén central

<!-- http://repo1.maven.org/maven2/com/xuxueli/xxl-job-core/ -->
<dependency>
    <groupId>com.xuxueli</groupId>
    <artifactId>xxl-job-core</artifactId>
    <version>${最新稳定版本}</version>
</dependency>

1. Diseño general

(1) Introducción al directorio fuente

- /doc :文档资料

- /db :“调度数据库”建表脚本

- /xxl-job-admin :调度中心，项目源码

- /xxl-job-core :公共Jar依赖

- /xxl-job-executor-samples :执行器，Sample示例项目（大家可以在该项目上进行开发，也可以将现有项目改造生成执行器项目）

(2) Configuración de "Base de datos de programación"

El módulo de programación XXL-JOB se basa en componentes de programación de desarrollo propio y admite la implementación de clústeres. La tabla de la base de datos de programación se describe a continuación:

- xxl_job_lock：任务调度锁表；

- xxl_job_group：执行器信息表，维护任务执行器信息；

- xxl_job_info：调度扩展信息表：用于保存XXL-JOB调度任务的扩展信息，如任务分组、任务名、机器地址、执行器、执行入参和报警邮件等等；

- xxl_job_log：调度日志表：用于保存XXL-JOB任务调度的历史信息，如调度结果、执行结果、调度入参、调度机器和执行器等等；

- xxl_job_log_report：调度日志报表：用户存储XXL-JOB任务调度日志的报表，调度中心报表功能页面会用到；

- xxl_job_logglue：任务GLUE日志：用于保存GLUE更新历史，用于支持GLUE的版本回溯功能；

- xxl_job_registry：执行器注册表，维护在线的执行器和调度中心机器地址信息；

- xxl_job_user：系统用户表；

(3) Diseño de arquitectura

1. Pensamiento de diseño

El comportamiento de despacho se abstrae en una plataforma pública de "centro de despacho", y la plataforma en sí misma no asume la lógica comercial, y el "centro de despacho" es responsable de iniciar las solicitudes de despacho.

Las tareas se abstraen en JobHandlers dispersos, que son administrados por el "ejecutor", y el "ejecutor" es responsable de recibir solicitudes de programación y ejecutar la lógica comercial en el JobHandler correspondiente.

Por lo tanto, las dos partes de "programación" y "tarea" se pueden desacoplar entre sí para mejorar la estabilidad y escalabilidad general del sistema;

2. Composición del sistema

Módulo de programación (centro de programación) :
responsable de administrar la información de programación, enviar solicitudes de programación de acuerdo con la configuración de programación y no es responsable de los códigos comerciales. El sistema de programación está desacoplado de las tareas, lo que mejora la disponibilidad y la estabilidad del sistema. Al mismo tiempo, el rendimiento del sistema de programación ya no está limitado por los módulos de tareas, sino que admite la gestión visual, simple y dinámica de la información de programación
. , incluida la creación, actualización, eliminación de tareas, desarrollo de GLUE y alarma de tareas, etc., todas las operaciones anteriores tendrán efecto en tiempo real y admitirán el monitoreo de los resultados de la programación y los registros de ejecución, y admitirán la conmutación por error del ejecutor.

Módulo de ejecución (ejecutor) :
responsable de recibir solicitudes de programación y ejecutar la lógica de tareas. El módulo de tareas se enfoca en operaciones como la ejecución de tareas, haciendo que el desarrollo y el mantenimiento sean más fáciles y eficientes; recibe
solicitudes de ejecución, solicitudes de finalización y solicitudes de registro del "centro de programación".

3. Diagrama de arquitectura

4. Análisis del módulo de programación

1. La falta de cuarzo

Como líder en la programación de trabajos de código abierto, Quartz es la primera opción para la programación de trabajos. Sin embargo, en el entorno del clúster, Quartz usa API para administrar tareas, a fin de evitar los problemas anteriores, pero también existen los siguientes problemas:

Problema 1: el método de llamar a la API para operar la tarea no está humanizado;
Pregunta 2: es necesario conservar el QuartzJobBean comercial en la tabla de datos subyacente, y el sistema es bastante intrusivo.
Pregunta 3: La lógica de programación y QuartzJobBean están acoplados en el mismo proyecto, lo que conducirá a un problema. Cuando la cantidad de tareas de programación aumenta gradualmente y la lógica de tareas de programación se agrava gradualmente, el rendimiento del sistema de programación será mucho mayor. limitado por el negocio en este momento;
Pregunta 4: La capa subyacente de cuarzo adquiere bloqueos DB de "manera preventiva" y el nodo de preferencia exitoso es responsable de ejecutar la tarea, lo que conducirá a una diferencia muy grande en la carga del nodo; mientras que XXL-JOB realiza la "distribución cooperativa "ejecutar la tarea a través del ejecutor, aprovechando al máximo las ventajas del clúster, la carga de cada nodo está equilibrada.

XXL-JOB compensa las deficiencias anteriores del cuarzo

2. Inicio rápido

2.1 Inicializar la "base de datos de programación"

Descargue el código fuente del proyecto y descomprímalo, obtenga el "Script SQL de inicialización de la base de datos de programación" y ejecútelo.

La ubicación de "Scheduling Database Initialization SQL Script" es:

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

El centro de despacho admite la implementación de clústeres y cada nodo debe estar conectado a la misma instancia de mysql en el caso de un clúster;

Si mysql es el maestro-esclavo, el nodo del clúster del centro de despacho debe forzar la biblioteca maestra;

2.2 Compilar el código fuente

Descomprima el código fuente, importe el código fuente en el IDE de acuerdo con el formato maven y compílelo con maven. La estructura del código fuente es la siguiente:

xxl-job-admin：调度中心
xxl-job-core：公共依赖
xxl-job-executor-samples：执行器Sample示例（选择合适的版本执行器，可直接使用，也可以参考其并将现有项目改造成执行器）
：xxl-job-executor-sample-springboot：Springboot版本，通过Springboot管理执行器，推荐这种方式；
：xxl-job-executor-sample-frameless：无框架版本；

2.3 Configurar e implementar el "centro de despacho"

调度中心项目：xxl-job-admin
作用：统一管理任务调度平台上调度任务，负责触发调度执行，并且提供任务管理平台。

Paso 1: Configuración del centro de despacho:

Dirección del archivo de configuración del centro de despacho:

/xxl-job/xxl-job-admin/src/main/resources/application.properties

Descripción del contenido de la configuración del centro de despacho:

### 调度中心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
[email protected]
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

Paso 2: implementar el proyecto:

Si la configuración anterior se ha realizado correctamente, el proyecto se puede compilar, empaquetar y desplegar.

Dirección de acceso al centro de despacho: http://localhost:8080/xxl-job-admin (esta dirección será utilizada por el ejecutor como la dirección de devolución de llamada)

La cuenta de inicio de sesión predeterminada es "admin/123456". Después de iniciar sesión, la interfaz en ejecución es como se muestra en la siguiente figura.

Hasta ahora, el proyecto del "centro de despacho" se ha implementado con éxito.

Paso 3: Clúster del centro de despacho (opcional):

El centro de despacho admite la implementación de clústeres para mejorar la recuperación ante desastres y la disponibilidad del sistema de despacho.

Al implementar un clúster de centro de despacho, hay varios requisitos y sugerencias:

La configuración de la base de datos se mantiene constante;
Los relojes de las máquinas del clúster se mantienen consistentes (desatendidos por el clúster independiente);
Sugerencia: se recomienda usar nginx para equilibrar la carga del clúster del centro de despacho y asignar nombres de dominio. Las operaciones como el acceso al centro de programación, la configuración de devolución de llamada del ejecutor y los servicios de API de llamadas se realizan a través de este nombre de dominio.

Otros: método de duplicación de Docker para construir un centro de despacho:

espejo de descarga

// Docker地址：https://hub.docker.com/r/xuxueli/xxl-job-admin/ (建议指定版本号)
docker pull xuxueli/xxl-job-admin

Crear un contenedor y ejecutar

docker run -p 8080:8080 -v /tmp:/data/applogs --name xxl-job-admin -d xuxueli/xxl-job-admin:{指定版本}

/**
* 如需自定义 mysql 等配置，可通过 "-e PARAMS" 指定，参数格式 PARAMS="--key=value --key2=value2" ；
* 配置项参考文件：/xxl-job/xxl-job-admin/src/main/resources/application.properties
* 如需自定义 JVM内存参数 等配置，可通过 "-e JAVA_OPTS" 指定，参数格式 JAVA_OPTS="-Xmx512m" ；
*/
docker run -e PARAMS="--spring.datasource.url=jdbc:mysql://127.0.0.1:3306/xxl_job?useUnicode=true&characterEncoding=UTF-8&autoReconnect=true&serverTimezone=Asia/Shanghai" -p 8080:8080 -v /tmp:/data/applogs --name xxl-job-admin -d xuxueli/xxl-job-admin:{指定版本}

2.4 Configurar y desplegar el "proyecto ejecutor"

“执行器”项目：xxl-job-executor-sample-springboot (提供多种版本执行器供选择，现以 springboot 版本为例，可直接使用，也可以参考其并将现有项目改造成执行器)
作用：负责接收“调度中心”的调度并执行；可直接部署执行器，也可以将执行器集成到现有业务项目中。

Paso 1: dependencia experta

Confirme que la dependencia maven de "xxl-job-core" se introduce en el archivo pom;

Paso 2: Configuración del actuador

Configuración del actuador, dirección del archivo de configuración:

/xxl-job/xxl-job-executor-samples/xxl-job-executor-sample-springboot/src/main/resources/application.properties

Configuración del actuador, descripción de la configuración:

### 调度中心部署根地址 [选填]：如调度中心集群部署存在多个地址则用逗号分隔。执行器将会使用该地址进行"执行器心跳注册"和"任务结果回调"；为空则关闭自动注册；
xxl.job.admin.addresses=http://127.0.0.1:8080/xxl-job-admin

### 执行器通讯TOKEN [选填]：非空时启用；
xxl.job.accessToken=

### 执行器AppName [选填]：执行器心跳注册分组依据；为空则关闭自动注册
xxl.job.executor.appname=xxl-job-executor-sample
### 执行器注册 [选填]：优先使用该配置作为注册地址，为空时使用内嵌服务 ”IP:PORT“ 作为注册地址。从而更灵活的支持容器类型执行器动态IP和动态映射端口问题。
xxl.job.executor.address=
### 执行器IP [选填]：默认为空表示自动获取IP，多网卡时可手动设置指定IP，该IP不会绑定Host仅作为通讯实用；地址信息用于 "执行器注册" 和 "调度中心请求并触发任务"；
xxl.job.executor.ip=
### 执行器端口号 [选填]：小于等于0则自动获取；默认端口为9999，单机部署多个执行器时，注意要配置不同执行器端口；
xxl.job.executor.port=9999
### 执行器运行日志文件存储磁盘路径 [选填] ：需要对该路径拥有读写权限；为空则使用默认路径；
xxl.job.executor.logpath=/data/applogs/xxl-job/jobhandler
### 执行器日志文件保存天数 [选填] ： 过期日志自动清理, 限制值大于等于3时生效; 否则, 如-1, 关闭自动清理功能；
xxl.job.executor.logretentiondays=30

Paso 3: Configuración del componente del actuador

Componente actuador, dirección del archivo de configuración:

/xxl-job/xxl-job-executor-samples/xxl-job-executor-sample-springboot/src/main/java/com/xxl/job/executor/core/config/XxlJobConfig.java

Componentes del actuador, descripción de la configuración:

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

    return xxlJobSpringExecutor;
}

Paso 4: implementar el proyecto ejecutor:

Si las configuraciones anteriores se han realizado correctamente, el proyecto del ejecutor se puede compilar e implementar. El sistema proporciona una variedad de proyectos de muestra del ejecutor. Simplemente elija uno de ellos. Los métodos de implementación respectivos son los siguientes.

xxl-job-executor-sample-springboot：项目编译打包成springboot类型的可执行JAR包，命令启动即可；
xxl-job-executor-sample-frameless：项目编译打包成JAR包，命令启动即可；

Hasta ahora se ha desplegado el proyecto "Actuador".

Paso 5: Clúster de ejecutores (opcional):

El ejecutor admite la implementación de clústeres, mejora la disponibilidad del sistema de programación y mejora las capacidades de procesamiento de tareas.

Al implementar clústeres de ejecutores, existen varios requisitos y sugerencias:

La dirección de devolución de llamada del ejecutor (xxl.job.admin.addresses) debe ser coherente; el ejecutor realiza operaciones como el registro automático del ejecutor de acuerdo con esta configuración.
El AppName (xxl.job.executor.appname) en el mismo clúster de ejecutores debe ser consistente; el centro de programación descubre dinámicamente las listas de ejecutores en línea de diferentes clústeres de acuerdo con esta configuración.

2.5 Desarrollar la primera tarea "Hola Mundo"

Este ejemplo toma como ejemplo la creación de una nueva tarea de "modo GLUE (Java)". Para obtener una configuración más detallada de las tareas, consulte el "Capítulo 3: Explicación detallada de las tareas".
(El código de ejecución del "modo GLUE (Java)" está alojado en el centro de despacho para el mantenimiento en línea, que es más simple y liviano que la "tarea del modo Bean" que debe desarrollarse e implementarse en el proyecto ejecutor).

Requisito previo: confirme que los proyectos "Centro de programación" y "Ejecutor" se hayan implementado e iniciado correctamente;

Paso 1: Crear una nueva tarea:

Inicie sesión en el centro de despacho y haga clic en el botón "Nueva tarea" como se muestra en la figura a continuación para crear una nueva tarea de muestra. Luego, consulte la configuración de parámetros de la tarea en la captura de pantalla a continuación y haga clic en Guardar.

Paso 2: Desarrollo de la tarea "Modo GLUE (Java)":

Haga clic en el botón "GLUE" en el lado derecho de la tarea para ingresar a la "interfaz de desarrollo del editor GLUE", como se muestra en la figura a continuación. La tarea en el modo de ejecución "Modo GLUE (Java)" ha inicializado el código de tarea de muestra de forma predeterminada, es decir, imprimiendo Hello World.
(La tarea del modo de operación "Modo GLUE (Java)" es en realidad una pieza de código de clase Java heredado de IJobHandler. Se ejecuta en el proyecto ejecutor y puede usar @Resource / @Autowire para inyectar otros servicios en el ejecutor. Detalles Consulte Capítulo 3)

Paso 3: Desencadenar la ejecución:

Haga clic en el botón "Ejecutar" en el lado derecho de la tarea para activar manualmente la ejecución de una tarea (por lo general, la programación de la tarea se activa configurando una expresión Cron).

Paso 4: Revisa el registro:

Haga clic en el botón "Registrar" en el lado derecho de la tarea para ir a la interfaz de registro de tareas para ver el registro de tareas.
En la interfaz de registro de tareas, puede ver los registros de programación históricos de la tarea, así como la información de programación de tareas, los parámetros de ejecución y la información de ejecución de cada programación. Haga clic en el botón "Registro de ejecución" en el lado derecho de la tarea en ejecución para ingresar a la consola de registro y ver el registro de ejecución en tiempo real.

En la consola de registro, puede ver la salida de información de registro de la tarea que se ejecuta en el lado del ejecutor en tiempo real en modo continuo y monitorear el progreso de la tarea en tiempo real;

3. Detalles de la tarea

Detalles de la propiedad de configuración:

基础配置：
- 执行器：任务的绑定的执行器，任务触发调度时将会自动发现注册成功的执行器, 实现任务自动发现功能; 另一方面也可以方便的进行任务分组。每个任务必须绑定一个执行器, 可在 "执行器管理" 进行设置;
- 任务描述：任务的描述信息，便于任务管理；
- 负责人：任务的负责人；
- 报警邮件：任务调度失败时邮件通知的邮箱地址，支持配置多邮箱地址，配置多个邮箱地址时用逗号分隔；

触发配置：
- 调度类型：
无：该类型不会主动触发调度；
CRON：该类型将会通过CRON，触发任务调度；
固定速度：该类型将会以固定速度，触发任务调度；按照固定的间隔时间，周期性触发；
固定延迟：该类型将会以固定延迟，触发任务调度；按照固定的延迟时间，从上次调度结束后开始计算延迟时间，到达延迟时间后触发下次调度；
- CRON：触发任务执行的Cron表达式；
- 固定速度：固定速度的时间间隔，单位为秒；
- 固定延迟：固定延迟的时间间隔，单位为秒；

任务配置：
- 运行模式：
BEAN模式：任务以JobHandler方式维护在执行器端；需要结合 "JobHandler" 属性匹配执行器中任务；
GLUE模式(Java)：任务以源码方式维护在调度中心；该模式的任务实际上是一段继承自IJobHandler的Java类代码并 "groovy" 源码方式维护，它在执行器项目中运行，可使用@Resource/@Autowire注入执行器里中的其他服务；
GLUE模式(Shell)：任务以源码方式维护在调度中心；该模式的任务实际上是一段 "shell" 脚本；
GLUE模式(Python)：任务以源码方式维护在调度中心；该模式的任务实际上是一段 "python" 脚本；
GLUE模式(PHP)：任务以源码方式维护在调度中心；该模式的任务实际上是一段 "php" 脚本；
GLUE模式(NodeJS)：任务以源码方式维护在调度中心；该模式的任务实际上是一段 "nodejs" 脚本；
GLUE模式(PowerShell)：任务以源码方式维护在调度中心；该模式的任务实际上是一段 "PowerShell" 脚本；
- JobHandler：运行模式为 "BEAN模式" 时生效，对应执行器中新开发的JobHandler类“@JobHandler”注解自定义的value值；
- 执行参数：任务执行所需的参数；

高级配置：
- 路由策略：当执行器集群部署时，提供丰富的路由策略，包括；
FIRST（第一个）：固定选择第一个机器；
LAST（最后一个）：固定选择最后一个机器；
ROUND（轮询）：；
RANDOM（随机）：随机选择在线的机器；
CONSISTENT_HASH（一致性HASH）：每个任务按照Hash算法固定选择某一台机器，且所有任务均匀散列在不同机器上。
LEAST_FREQUENTLY_USED（最不经常使用）：使用频率最低的机器优先被选举；
LEAST_RECENTLY_USED（最近最久未使用）：最久未使用的机器优先被选举；
FAILOVER（故障转移）：按照顺序依次进行心跳检测，第一个心跳检测成功的机器选定为目标执行器并发起调度；
BUSYOVER（忙碌转移）：按照顺序依次进行空闲检测，第一个空闲检测成功的机器选定为目标执行器并发起调度；
SHARDING_BROADCAST(分片广播)：广播触发对应集群中所有机器执行一次任务，同时系统自动传递分片参数；可根据分片参数开发分片任务；
- 子任务：每个任务都拥有一个唯一的任务ID(任务ID可以从任务列表获取)，当本任务执行结束并且执行成功时，将会触发子任务ID所对应的任务的一次主动调度。
- 调度过期策略：
- 忽略：调度过期后，忽略过期的任务，从当前时间开始重新计算下次触发时间；
- 立即执行一次：调度过期后，立即执行一次，并从当前时间开始重新计算下次触发时间；
- 阻塞处理策略：调度过于密集执行器来不及处理时的处理策略；
单机串行（默认）：调度请求进入单机执行器后，调度请求进入FIFO队列并以串行方式运行；
丢弃后续调度：调度请求进入单机执行器后，发现执行器存在运行的调度任务，本次请求将会被丢弃并标记为失败；
覆盖之前调度：调度请求进入单机执行器后，发现执行器存在运行的调度任务，将会终止运行中的调度任务并清空队列，然后运行本地调度任务；
- 任务超时时间：支持自定义任务超时时间，任务运行超时将会主动中断任务；
- 失败重试次数；支持自定义任务失败重试次数，当任务失败时将会按照预设的失败重试次数主动进行重试；

3.1 Modo BEAN (formulario de clase)

Las tareas en modo Bean admiten el desarrollo basado en clases y cada tarea corresponde a una clase Java.

Ventajas: No limita el entorno del proyecto y tiene buena compatibilidad. Incluso los proyectos sin marco, como los proyectos iniciados directamente por el método principal, también pueden brindar soporte, puede consultar el proyecto de muestra "xxl-job-executor-sample-frameless";
defecto:
- Cada tarea necesita ocupar una clase de Java, lo que resulta en una pérdida de clases;
- No se admite el escaneo automático de tareas ni la inyección en el contenedor del ejecutor, se requiere la inyección manual.

Paso 1: en el proyecto ejecutor, desarrolle la clase Job:

1、开发一个继承自"com.xxl.job.core.handler.IJobHandler"的JobHandler类，实现其中任务方法。
2、手动通过如下方式注入到执行器容器。
```
XxlJobExecutor.registJobHandler("demoJobHandler", new DemoJobHandler());
```

Paso 2: centro de programación, cree una nueva tarea de programación

Los pasos posteriores son consistentes con el "modo 3.2 BEAN (forma de método)", puede consultarlo.

3.2 Modo BEAN (forma de método)

La tarea del modo Bean admite el método de desarrollo basado en métodos y cada tarea corresponde a un método.

ventaja:
- Cada tarea solo necesita desarrollar un método y agregar la anotación " @XxlJob ", que es más conveniente y rápida.
- Admite el escaneo automático de tareas y la inyección en el contenedor ejecutor.
Desventajas: Se requiere un entorno de contenedor de resorte;

Para las tareas basadas en métodos, la capa inferior generará un proxy JobHandler.Al igual que el método basado en clases, las tareas también existirán en el contenedor de tareas del ejecutor en forma de JobHandler.

Paso 1: En el proyecto ejecutor, desarrolle el método Job:

1、任务开发：在Spring Bean实例中，开发Job方法；
2、注解配置：为Job方法添加注解 "@XxlJob(value="自定义jobhandler名称", init = "JobHandler初始化方法", destroy = "JobHandler销毁方法")"，注解value值对应的是调度中心新建任务的JobHandler属性的值。
3、执行日志：需要通过 "XxlJobHelper.log" 打印执行日志；
4、任务结果：默认任务结果为 "成功" 状态，不需要主动设置；如有诉求，比如设置任务结果为失败，可以通过 "XxlJobHelper.handleFail/handleSuccess" 自主设置任务结果；
// 可参考Sample示例执行器中的 "com.xxl.job.executor.service.jobhandler.SampleXxlJob" ，如下：
@XxlJob("demoJobHandler")
public void demoJobHandler() throws Exception {
XxlJobHelper.log("XXL-JOB, Hello World.");
}

Paso 2: centro de programación, cree una nueva tarea de programación

Consulte la "Descripción detallada de las propiedades de configuración" anterior para configurar los parámetros para la tarea recién creada, seleccione "Modo BEAN" como el modo operativo y complete el valor definido en la anotación de la tarea "@XxlJob" para la propiedad JobHandler ;

Tareas nativas de patrón Bean incorporadas

Para la conveniencia de la referencia del usuario y la practicidad rápida, el ejecutor de ejemplo proporciona múltiples controladores de tareas en modo Bean de forma nativa, que pueden configurarse directamente y ser prácticos, de la siguiente manera:

demoJobHandler: una tarea de muestra simple, que simula la lógica de la tarea que consume mucho tiempo dentro de la tarea, y los usuarios pueden experimentar funciones como Rolling Log en línea;
shardingJobHandler: tarea de ejemplo de fragmentación, que simula y procesa parámetros de fragmentación dentro de la tarea; consulte Familiarizarse con las tareas de fragmentación;
httpJobHandler: controlador general de tareas HTTP; el lado comercial solo necesita proporcionar información como enlaces HTTP, y no hay restricciones de idiomas y plataformas. Los parámetros de entrada de la tarea de ejemplo son los siguientes:
1. url: http://www.xxx.com
2. method: get 或 post
3. data: post-data
commandJobHandler: controlador general de tareas de la línea de comandos; el lado comercial solo necesita proporcionar la línea de comandos, como el comando "pwd";

3.3 Modo PEGAMENTO (Java)

La tarea se mantiene en el centro de despacho en forma de código fuente, admite la actualización en línea a través del IDE web y se compila y surte efecto en tiempo real, por lo que no es necesario especificar un JobHandler. El proceso de desarrollo es el siguiente:

Paso 1: en el centro de programación, cree una nueva tarea de programación:

Consulte la "Descripción detallada de las propiedades de configuración" anterior para configurar los parámetros para la tarea recién creada y seleccione "Modo GLUE (Java)" como modo operativo;

Paso 2: desarrollar código de tarea:

Seleccione la tarea especificada, haga clic en el botón "GLUE" en el lado derecho de la tarea e irá a la interfaz Web IDE de la tarea GLUE, que admite el desarrollo del código de la tarea (también puede copiarlo y pegarlo en el editor después de que se complete el desarrollo en el IDE).

Función de seguimiento de la versión (se admite el seguimiento de la versión de 30 versiones): en la interfaz web IDE de la tarea GLUE, seleccione el cuadro desplegable "Version Backtracking" en la esquina superior derecha y se mostrará el historial de actualizaciones de GLUE. Seleccione la versión correspondiente para mostrar el código de versión. Después de guardar, el código GLUE volverá a la versión histórica correspondiente;

3.4 Modo PEGAMENTO (Carcasa)

Paso 1: en el centro de programación, cree una nueva tarea de programación

Consulte la "Descripción detallada de las propiedades de configuración" anterior para configurar los parámetros de la tarea recién creada y seleccione "Modo GLUE (Shell)" como modo de funcionamiento;

Paso 2: desarrollar código de tarea:

La tarea de este modo es en realidad un script "shell";

3.4 Modo PEGAMENTO (Python)

Paso 1: en el centro de programación, cree una nueva tarea de programación

Consulte la "Descripción detallada de las propiedades de configuración" anterior para configurar los parámetros de la tarea recién creada y seleccione "Modo GLUE (Python)" como modo de funcionamiento;

Paso 2: desarrollar código de tarea:

La tarea de este modo es en realidad un script "python";

3.5 Modo PEGAMENTO (NodeJS)

Paso 1: en el centro de programación, cree una nueva tarea de programación

Consulte la "Descripción detallada de las propiedades de configuración" anterior para configurar los parámetros de la tarea recién creada y seleccione "Modo GLUE (NodeJS)" como modo operativo;

Paso 2: desarrollar código de tarea:

La tarea de este modo es en realidad un script "nodeJS";

3.6 Modo PEGAMENTO (PHP)

ídem

3.7 Modo PEGAMENTO (PowerShell)

ídem

4. Guía de operación

4.1 Configuración del actuador

Haga clic para ingresar a la interfaz de "Gestión de Ejecutores", como se muestra en la siguiente figura:

1、"调度中心OnLine:"右侧显示在线的"调度中心"列表, 任务执行结束后, 将会以failover的模式进行回调调度中心通知执行结果, 避免回调的单点风险;
2、"执行器列表" 中显示在线的执行器列表, 可通过"OnLine 机器"查看对应执行器的集群机器。

Haga clic en el botón "+ Agregar actuador" y el cuadro emergente es como se muestra en la figura a continuación, puede agregar una configuración de actuador:

Descripción de la propiedad del actuador

AppName: 是每个执行器集群的唯一标示AppName, 执行器会周期性以AppName为对象进行自动注册。可通过该配置自动发现注册成功的执行器, 供任务调度时使用;
名称: 执行器的名称, 因为AppName限制字母数字等组成,可读性不强, 名称为了提高执行器的可读性;
排序: 执行器的排序, 系统中需要执行器的地方,如任务新增, 将会按照该排序读取可用的执行器列表;
注册方式：调度中心获取执行器地址的方式；
自动注册：执行器自动进行执行器注册，调度中心通过底层注册表可以动态发现执行器机器地址；
手动录入：人工手动录入执行器的地址信息，多地址逗号分隔，供调度中心使用；
机器地址："注册方式"为"手动录入"时有效，支持人工维护执行器的地址信息；

4.2 Crear una nueva tarea

Ingrese a la interfaz de administración de tareas, haga clic en el botón "Agregar tarea", configure las propiedades de la tarea en la interfaz emergente "Agregar tarea" y guárdela. Para la página de detalles, consulte el capítulo "3. Explicación detallada de la tarea".

4.3 Tareas de edición

Ingrese a la interfaz de administración de tareas, seleccione la tarea especificada. Haga clic en el botón "Editar" en el lado derecho de la tarea, actualice las propiedades de la tarea en la interfaz emergente "Editar tarea" y guárdela. Puede modificar la información de propiedad de la tarea establecida:

4.4 Editar código de PEGAMENTO

Esta operación es solo para tareas de GLUE.

Seleccione la tarea especificada y haga clic en el botón "GLUE" en el lado derecho de la tarea para ir a la interfaz Web IDE de la tarea GLUE, que admite el desarrollo del código de la tarea. Consulte el capítulo "3.3 Modo GLUE (Java)".

4.5 Iniciar/detener tareas

Las tareas se pueden "iniciar" y "detener".
Debe tenerse en cuenta que el inicio/detención aquí es solo para el comportamiento de activación de la programación posterior de la tarea y no afectará las tareas programadas que ya se han activado. Si necesita finalizar las tareas programadas que se han activado, consulte a "4.9 Finalizar tareas en ejecución"

4.6 Activar manualmente un horario

Haga clic en el botón "Ejecutar" para activar manualmente la programación de una tarea sin afectar las reglas de programación originales.

4.7 Ver registro de programación

Haga clic en el botón "Registrar" para ver el registro de programación del historial de tareas. En la interfaz del registro de transferencia del historial, puede ver los resultados de la programación y los resultados de la ejecución de cada programación de tareas y hacer clic en el botón "Registro de ejecución" para ver el registro completo del ejecutor.

调度时间："调度中心"触发本次调度并向"执行器"发送任务执行信号的时间；
调度结果："调度中心"触发本次调度的结果，200表示成功，500或其他表示失败；
调度备注："调度中心"触发本次调度的日志信息；
执行器地址：本次任务执行的机器地址
运行模式：触发调度时任务的运行模式，运行模式可参考章节 "三、任务详解"；
任务参数：本地任务执行的入参
执行时间："执行器"中本次任务执行结束后回调的时间；
执行结果："执行器"中本次任务执行的结果，200表示成功，500或其他表示失败；
执行备注："执行器"中本次任务执行的日志信息；
操作：
"执行日志"按钮：点击可查看本地任务执行的详细日志信息；详见“4.8 查看执行日志”；
"终止任务"按钮：点击可终止本地调度对应执行器上本任务的执行线程，包括未执行的阻塞任务一并被终止；

4.8 Ver registro de ejecución

Haga clic en el botón "Registro de ejecución" en el lado derecho del registro de ejecución para saltar a la interfaz del registro de ejecución, donde puede ver el registro completo impreso en el código comercial, como se muestra en la figura a continuación;

4.9 Terminar tareas en ejecución

Solo para ejecutar tareas.
En la interfaz de registro de tareas, haga clic en el botón "Terminar tarea" a la derecha y se enviará una solicitud de finalización de tarea al ejecutor correspondiente a esta tarea, y esta tarea finalizará y toda la cola de ejecución de tareas se borrará en al mismo tiempo.

Cuando finaliza la tarea, se implementa "interrumpiendo" el subproceso de ejecución y se activará una excepción "InterruptedException". Por lo tanto, si la excepción se detecta y se digiere dentro de JobHandler, la función de terminación de tareas no estará disponible.

Por lo tanto, si la finalización de la tarea mencionada anteriormente no está disponible, es necesario realizar un manejo especial (lanzar hacia arriba) para la excepción "InterruptedException" en JobHandler. La lógica correcta es la siguiente:

try{
// do something
} catch (Exception e) {
if (e instanceof InterruptedException) {
throw e;
}
logger.warn("{}", e);
}

Además, cuando el subproceso secundario se inicia en JobHandler, el subproceso secundario no puede capturar y manejar "InterruptedException", y debe lanzarlo activamente hacia arriba.

Cuando finaliza la tarea, se ejecutará el método "destroy()" correspondiente a JobHandler, que se puede usar para manejar alguna lógica de recuperación de recursos.

4.10 Eliminar registro de ejecución

En la interfaz de registro de tareas, después de seleccionar el ejecutor y la tarea, haga clic en el botón "Eliminar" a la derecha y aparecerá un cuadro emergente "Limpieza de registro". El cuadro emergente admite la selección de diferentes tipos de limpieza de registro estrategias Después de seleccionarlo, haga clic en el botón "Aceptar". Puede realizar operaciones de limpieza de registro;

4.11 Eliminar tarea

Haga clic en el botón Eliminar para eliminar la tarea correspondiente.

4.12 Gestión de usuarios

Ingrese a la interfaz de "Administración de usuarios" para ver y administrar la información del usuario;

Actualmente los usuarios se dividen en dos roles:

Administrador: tiene plena autoridad, admite la gestión en línea de la información del usuario, asigna autoridad a los usuarios y la granularidad de la asignación de autoridad es ejecutor;
Usuarios ordinarios: solo tienen asignados los permisos de ejecutores, y los permisos de operación de las tareas relacionadas;

Java -- Plataforma de programación de tareas distribuidas XXL-JOB

1. Diseño general

(1) Introducción al directorio fuente

(2) Configuración de "Base de datos de programación"

(3) Diseño de arquitectura

1. Pensamiento de diseño

2. Composición del sistema

3. Diagrama de arquitectura

4. Análisis del módulo de programación

2. Inicio rápido

2.1 Inicializar la "base de datos de programación"

2.2 Compilar el código fuente

2.3 Configurar e implementar el "centro de despacho"

2.4 Configurar y desplegar el "proyecto ejecutor"

2.5 Desarrollar la primera tarea "Hola Mundo"

3. Detalles de la tarea

Detalles de la propiedad de configuración:

3.1 Modo BEAN (formulario de clase)

3.2 Modo BEAN (forma de método)

3.3 Modo PEGAMENTO (Java)

3.4 Modo PEGAMENTO (Carcasa)

3.4 Modo PEGAMENTO (Python)

3.5 Modo PEGAMENTO (NodeJS)

3.6 Modo PEGAMENTO (PHP)

3.7 Modo PEGAMENTO (PowerShell)

4. Guía de operación

4.1 Configuración del actuador

4.2 Crear una nueva tarea

4.3 Tareas de edición

4.4 Editar código de PEGAMENTO

4.5 Iniciar/detener tareas

4.6 Activar manualmente un horario

4.7 Ver registro de programación

4.8 Ver registro de ejecución

4.9 Terminar tareas en ejecución

4.10 Eliminar registro de ejecución

4.11 Eliminar tarea

4.12 Gestión de usuarios

Supongo que te gusta