3.000 palabras lo llevan a comprender la plataforma de programación de tareas XXL-JOB

mapas mentales

El artículo ha sido incluido en la selección de Github, bienvenido a Star : https://github.com/yehongzhi/learningSummary

I. Resumen

En escenarios comerciales normales, a menudo hay algunos escenarios que necesitan usar tareas programadas, como:

• Escenario impulsado por el tiempo: envíe cupones en un momento determinado, envíe SMS, etc.
• Datos de procesamiento por lotes: estadísticas de lotes de las facturas del mes pasado, estadísticas de los datos de ventas del mes pasado, etc.
• Escenario de frecuencia fija: debe ejecutarse cada 5 minutos.

Por lo tanto, las tareas cronometradas no son infrecuentes en el desarrollo normal, y en la era del consumo rápido, es necesario enviar varios empujes todos los días y los mensajes deben completarse con tareas cronometradas, que es muy utilizado.

2. ¿Por qué necesita una plataforma de programación de tareas?

En Java, las soluciones tradicionales de implementación de tareas de temporización, como Timer, Quartz, etc., tienen más o menos problemas:

• Sin soporte de clúster, sin estadísticas, sin plataforma de administración, sin alarma de falla, sin monitoreo, etc.

Y en la arquitectura distribuida actual, hay algunos escenarios que requieren una programación de tareas distribuida:

• Cuando las tareas de varias instancias del mismo servicio son mutuamente excluyentes, se requiere una programación unificada.
• La programación de tareas debe admitir alarmas de falla, monitoreo y alta disponibilidad.
• Es necesario administrar y rastrear uniformemente los resultados de la programación de tareas de cada nodo de servicio, y es necesario registrar y guardar la información de los atributos de la tarea.

Obviamente, las tareas de temporización tradicionales ya no son suficientes para la arquitectura distribuida actual, por lo que se necesita una plataforma de programación de tareas distribuidas. En la actualidad, las más convencionales son elasticjob y xxl-job.

Elasticjob es de código abierto de Dangdang. Actualmente, github tiene 6.5k Star y 76 empresas están registradas en el sitio web oficial.

A diferencia de xxl-job, elasticjob usa zookeeper para implementar la coordinación distribuida y lograr una alta disponibilidad y fragmentación de tareas.

Tres, por qué elegir XXL-JOB

De hecho, más empresas eligen xxl-job. Actualmente , hay 15,7k estrellas en github de xxl-job y 348 empresas registradas . No hay duda de que tanto elasticjob como xxl-job son marcos técnicos excelentes. A continuación, compararemos, analizaremos y exploraremos por qué más empresas eligen xxl-job.

Primero, introduzca xxl-job. Este es un proyecto de código abierto de Dianping Xu Xueli (xxl es la primera letra del nombre del autor). El sitio web oficial lo presenta como un marco de programación de tareas distribuido y ligero. Su objetivo principal de diseño es el desarrollo rápido. , Fácil de aprender, ligero y fácil de ampliar. A diferencia de elasticjob, el entorno xxl-job se basa en mysql en lugar de ZooKeeper, que también es la mayor diferencia.

La intención original de elasticjob es enfrentar servicios complejos con alta concurrencia, incluso cuando el volumen de negocio es grande y hay muchos servidores, puede hacer un buen trabajo de programación y utilizar los recursos del servidor tanto como sea posible. Use ZooKeeper para que sea altamente disponible, consistente y escalable. El trabajo elástico escrito en el sitio web oficial está descentralizado. El servidor principal se elige a través del mecanismo de elección de ZooKeeper. Si el servidor principal falla, se reelegirá un nuevo servidor principal. Por tanto, elasticjob tiene buena escalabilidad y disponibilidad, pero su uso y operación y mantenimiento son algo complicados .

xxl-job es lo opuesto. Utiliza una plataforma de programación centralizada para programar múltiples ejecutores para que realicen tareas. El centro de programación usa bloqueos DB para garantizar la consistencia de la programación distribuida del clúster, de modo que la expansión de los ejecutores aumentará la presión sobre DB, pero si De hecho, la base de datos aquí solo es responsable de la programación y ejecución de tareas. Pero sin una gran cantidad de ejecutores y tareas, no causará presión en la base de datos. De hecho, la mayoría de las empresas no tienen muchos ejecutores (aunque las entrevistas suelen plantear algunas preguntas de alta concurrencia).

En términos relativos, la plataforma de programación centralizada xxl-job es liviana, lista para usar , fácil de operar, rápida para comenzar y tiene una muy buena integración con SpringBoot , y la interfaz de monitoreo está integrada en el centro de programación, y la interfaz es simple y conveniente para las empresas. El costo de mantenimiento no es alto y hay alertas por correo electrónico fallidas, etc. Esto hace que muchas empresas elijan xxl-job como plataforma de programación.

Cuatro, instalación

4.1 Extraer el código fuente

La configuración de xxl-job es muy simple. Hay dos formas de implementar la imagen de Docker Pull y la compilación del código fuente. La forma de implementar la Docker es relativamente simple. Hablaré sobre la compilación del código fuente. Primero vaya a github para extraer el código fuente de xxl-job al local.

4.2 Importar IDEA

Después de extraer el código fuente, puede ver la estructura del proyecto de la siguiente manera:

Importarlo a IDEA, configurar Maven, descargar el paquete jar relevante, después de un tiempo, puede ver dicho proyecto:

4.3 Inicializar la base de datos

Como se mencionó anteriormente, xxl-job necesita depender de mysql, por lo que es necesario inicializar la base de datos. Busque el archivo tables_xxl_job.sql en la ruta xxl-jobdocdb. Ejecute el archivo sql en mysql.

4.4 Archivo de configuración

Luego, cambie el archivo de configuración y busque el archivo application.properties en el proyecto de administración.

### 调度中心JDBC链接
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=
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=10

4.5 Compilar y ejecutar

Simplemente ejecute el método principal del proyecto de administración para iniciarlo.

Si está implementado en el servidor, entonces debemos empaquetarlo en un paquete jar y usar el complemento Maven para empaquetarlo en IDEA.

Luego, busque el paquete jar en la ruta xxl-jobxxl-job-admintarget.

Luego obtienes el paquete jar y puedes iniciarlo con el comando java -jar.

¡Está hecho aquí! Abra el navegador e ingrese http: // localhost: 8080 / xxl-job-admin para ingresar a la página de administración. Cuenta / contraseña predeterminada: admin / 123456.

Cinco, por siempre Hola palabra

Una vez implementado el centro de despacho, debe registrar al ejecutor en el centro de despacho y agregar tareas de programación. A continuación, escriba un ejemplo sencillo con referencia a xxl-job.

Primero cree un proyecto SpringBoot llamado "xxljob-demo" y agregue las dependencias.

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
    </dependency>
    <dependency><!-- 官网的demo是2.2.1，中央maven仓库还没有，所以就用2.2.0 -->
        <groupId>com.xuxueli</groupId>
        <artifactId>xxl-job-core</artifactId>
        <version>2.2.0</version>
    </dependency>
</dependencies>

Luego modifique application.properties.

# web port
server.port=8081
# log config
logging.config=classpath:logback.xml
spring.application.name=xxljob-demo
### 调度中心部署跟地址 [选填]：如调度中心集群部署存在多个地址则用逗号分隔。执行器将会使用该地址进行"执行器心跳注册"和"任务结果回调"；为空则关闭自动注册；
xxl.job.admin.addresses=http://127.0.0.1:8080/xxl-job-admin
### 执行器通讯TOKEN [选填]：非空时启用；
xxl.job.accessToken=
### 执行器AppName [选填]：执行器心跳注册分组依据；为空则关闭自动注册
xxl.job.executor.appname=xxl-job-demo
### 执行器注册 [选填]：优先使用该配置作为注册地址，为空时使用内嵌服务 ”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=10

Luego escribe una clase de configuración XxlJobConfig.

@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;
    }
}

Luego escriba una clase de tarea XxlJobDemoHandler, usando el modo Bean.

@Component
public class XxlJobDemoHandler {
    /**
     * 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" 打印执行日志；
     */
    @XxlJob("demoJobHandler")
    public ReturnT<String> demoJobHandler(String param) throws Exception {
        XxlJobLogger.log("java, Hello World~~~");
        XxlJobLogger.log("param:" + param);
        return ReturnT.SUCCESS;
    }
}

En el directorio de recursos, agregue el archivo 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="/data/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>

Después de escribir, inicie el servicio, luego puede abrir la interfaz de administración, encontrar la administración del actuador y agregar el actuador.

Luego vaya a la gestión de tareas y agregue tareas.


Finalmente, podemos ir a la gestión de tareas para probar y ejecutar demoJobHandler.


Después de hacer clic en guardar, se ejecutará inmediatamente. Haga clic en Ver registro, puede ver el registro histórico de ejecución de tareas.

Abra el registro de ejecución recién ejecutado, podemos ver que la operación fue exitosa.

Esta es una demostración de demostración simple, muy simple y rápida de comenzar.

Seis, habla de diseño arquitectónico

Hablemos brevemente sobre la arquitectura de xxl-job. Primero veamos un diagrama de arquitectura proporcionado por el sitio web oficial para su análisis.

Como puede verse en el diagrama de arquitectura, hay dos componentes principales del centro de despacho y el actuador.

• Centro de despacho. 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 responsable de los códigos comerciales. Admite la interfaz visual, puede agregar, actualizar y eliminar tareas en el centro de despacho, que entrará en vigencia en tiempo real. Admite el monitoreo de resultados de programación, visualización de registros de ejecución, visualización de informes estadísticos de tareas de programación, alarmas de fallas de tareas, etc.
• Solenoide. Responsable de recibir solicitudes de programación y ejecutar la lógica empresarial de las tareas de programación. Una vez que se inicia el actuador, debe registrarse en el centro de envío. Reciba solicitudes de ejecución, solicitudes de terminación, solicitudes de registro, etc. desde el centro de despacho.

A continuación, analizamos el principio de funcionamiento de xxl-job.

• El ejecutor de la tarea se registra automáticamente en el centro de envío de acuerdo con la dirección del centro de envío configurado.
• Cuando se alcanza la condición de activación de la tarea, el centro de despacho emite la tarea.
• El ejecutor ejecuta tareas basadas en el grupo de subprocesos, coloca los resultados de la ejecución en la cola de memoria y escribe el registro de ejecución en el archivo de registro.
• El hilo de devolución de llamada del ejecutor consume el resultado de la ejecución en la cola de memoria y lo informa activamente al centro de despacho.
• Cuando el usuario ve el registro de tareas en el centro de despacho, el centro de despacho solicita al ejecutor de tareas y el ejecutor de tareas lee el archivo de registro de tareas y devuelve los detalles del registro.

Hablar

Después de leer el contenido anterior, básicamente eres un principiante. De hecho, xxl-job todavía tiene muchas funciones. Para estudiar en profundidad, es necesario ir al sitio web oficial para estudiar y explorar. La mejor manera es construir un trabajo xxl localmente para jugar y jugar, la práctica práctica es la forma más rápida de aprender.

 

Enlace original
Este artículo es el contenido original de Alibaba Cloud y no se puede reproducir sin permiso.