任务调度 on Liangweidong's blog

SonarQube + PowerJob：代码质量与分布式任务调度实战

Mon, 15 Dec 2025 00:00:00 +0800

SonarQube 是代码质量"门禁"的事实标准（2007 年首发，2024 改名为 SonarQube Server）；PowerJob 是阿里 2019 年开源的分布式任务调度平台（“取代 XXL-JOB” 的新秀）。两个工具配合：SonarQube 守"代码质量门禁"，PowerJob 跑"分布式定时任务"。这篇文章把两者的 Docker 化、Jenkins 集成、PostgreSQL 后端实战一次性说清。

阅读对象：DevOps / 平台工程团队；Java 团队需要"代码扫描 + Jenkins 集成"；需要"分布式定时任务 + 工作流引擎"的业务团队。 覆盖范围：SonarQube 26.x 容器化部署（PG 后端）、sysctl/limits.conf 调优、token 创建、sonar-scanner 集成、Jenkins pipeline；PowerJob 5.1.x Server 启动、Worker 接入、PG/MySQL 后端、序列与字段类型修复。

一、SonarQube 部署

1.1 前置要求

SonarQube 自带 Elasticsearch，对内核参数有要求：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


# 1. 内核参数（必须）
sysctl -w vm.max_map_count=524288
sysctl -w fs.file-max=131072
ulimit -n 131072
ulimit -u 8192

# 2. 永久生效
sudo sh -c 'cat >> /etc/sysctl.conf << EOF
vm.max_map_count=524288
fs.file-max=131072
EOF'
sudo sysctl -p

sudo sh -c 'cat >> /etc/security/limits.conf << EOF
* soft nofile 131072
* hard nofile 131072
* soft nproc 8192
* hard nproc 8192
EOF'

ulimit -n

不调会怎样？ Elasticsearch 启动失败，日志报 max file descriptors [4096] for elasticsearch process is too low / max virtual memory areas vm.max_map_count [65530] is too low。

1.2 拉取与启动

1

docker pull sonarqube:26.5.0.122743-community

26.x 是 2026+ 时代（社区版免费，企业版含 AI CodeFix、SAST、SCA）。早期用户常用 8.9.2 LTS / 9.x LTS。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


mkdir -p /home/docker/sonarqube/{data,logs,extensions}
sudo chown -R 1000:1000 /home/docker/sonarqube

docker run -d \
 --name sonarqube \
 --restart=always \
 --net=host \
 -e SONAR_JDBC_URL="jdbc:postgresql://localhost:5432/sonarqube?sslmode=disable" \
 -e SONAR_JDBC_USERNAME=postgres \
 -e SONAR_JDBC_PASSWORD={{REDACTED}} \
 -v /home/docker/sonarqube/data:/opt/sonarqube/data \
 -v /home/docker/sonarqube/logs:/opt/sonarqube/logs \
 -v /home/docker/sonarqube/extensions:/opt/sonarqube/extensions \
 sonarqube:26.5.0.122743-community

关键：

--net=host：避免 Elasticsearch 集群模式下容器间无法直接组网

chown 1000:1000：SonarQube 以 UID 1000 跑

必须配置外部数据库：默认 H2 不适合生产

1.3 首次登录

访问 http://<host>:9000
默认 admin / admin，强制修改密码（如 Admin#123456）
创建 Token：
- 我的账号 → 安全 → 输入 Token 名称 → 类型选 user token → 过期时间永不
- 记录 Token（如 squ_322a479dc2252a96aa930ec3f680e78fb216237f）

1.4 汉化插件

离线：github.com/xuhuisheng/sonar-l10n-zh 下载匹配版本
放到 extensions/downloads/ 或 extensions/plugins/
重启 SonarQube

也可以在 Marketplace 直接搜索 “Chinese Pack” 在线安装。

二、sonar-scanner + Jenkins 集成

2.1 准备 sonar-scanner

1
2
3
4


# 下载 sonar-scanner CLI
wget https://binaries.sonarsource.com/Distribution/sonar-scanner-cli/sonar-scanner-cli-4.6.2.2472.zip
unzip sonar-scanner-cli-4.6.2.2472.zip
mv sonar-scanner-4.6.2.2472 /opt/sonar-scanner

sonar-scanner 4.6.x 用 JDK 8，9.x+ 需 JDK 11+。SonarQube 9.x 之后 scanner 也要求 JDK 11+。

2.2 Jenkins 全局工具配置

Jenkins → 系统管理 → 全局工具配置 → SonarQube Scanner → 新增安装 → 选版本。

2.3 Jenkins 系统配置

Jenkins → 系统管理 → 系统配置 → SonarQube servers → Add SonarQube：

字段	值
Name	`SonarQube`
Server URL	`http://internal.example.com:9010`
Server authentication token	粘贴 SonarQube 的 `squ_...` token

2.4 Jenkinsfile pipeline

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


pipeline {
 agent any
 stages {
 stage('SonarQube Analysis') {
 steps {
 script {
 def scannerHome = tool 'sonarqube';
 sh """
 ${scannerHome}/bin/sonar-scanner \
 -Dsonar.host.url=http://internal.example.com:9010 \
 -Dsonar.login=admin \
 -Dsonar.password={{REDACTED}} \
 -Dsonar.sources=. \
 -Dsonar.sourceEncoding=UTF-8 \
 -Dsonar.projectVersion=${BUILD_NUMBER} \
 -Dsonar.projectKey=${JOB_NAME} \
 -Dsonar.projectName=${JOB_NAME} \
 -Dsonar.language=java \
 -Dsonar.java.binaries=${WORKSPACE} \
 -Dsonar.exclusions=**/target/**,**/resources/**,**/*.xml
 """
 }
 }
 }
 }
}

2.5 Java 项目 `sonar-project.properties`

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


sonar.sources=.
sonar.sourceEncoding=UTF-8
sonar.projectVersion=$BUILD_NUMBER
sonar.projectName=safe-backend-app
sonar.projectKey=safe-backend-app
sonar.host.url=http://internal.example.com:9010
sonar.login=admin
sonar.password={{REDACTED}}
sonar.verbose=true
sonar.analysisCache.enabled=false
sonar.log.level=INFO
sonar.language=java
sonar.java.binaries=$WORKSPACE
sonar.exclusions=**/target/**,**/resources/**,**/*.xml

2.6 JS / 前端项目

1
2
3
4
5
6
7


sonar.projectKey=safe-frontend-dev
sonar.projectName=safe-frontend-dev
sonar.projectVersion=1.0
sonar.language=js
sonar.sourceEncoding=UTF-8
sonar.sources=$WORKSPACE
sonar.exclusions=**/node_modules/**

三、PowerJob 部署

PowerJob 是阿里 2019 年开源的分布式任务调度平台，比 XXL-JOB 更现代（支持 MapReduce、工作流、K8s、容器化 Worker）。

3.1 启动 Server（MySQL 后端）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


docker pull powerjob/powerjob-server:5.1.0

docker run -d \
 --restart=always \
 --name powerjob \
 --network=host \
 -e TZ="Asia/Shanghai" \
 -e JVMOPTIONS="-Dpowerjob.network.local.address=10.xx.xx.xx -Dpowerjob.network.external.address=x.x.x.x -Dpowerjob.network.external.port.http=10010" \
 -e PARAMS="--spring.profiles.active=product \
 --spring.datasource.core.jdbc-url=jdbc:mysql://localhost:3306/powerjob?useUnicode=true&characterEncoding=UTF-8 \
 --spring.datasource.core.username=root \
 --spring.datasource.core.password={{REDACTED}} \
 --oms.http.port=10010 --server.port=7700 --oms.akka.port=10086" \
 -v /home/docker/powerjob-server:/root/powerjob/server \
 internal.example.com/base/powerjob/powerjob-server:5.1.0

三个端口：

7700：Web UI

10010：HTTP API（Worker 注册 + 任务调度）

10086：Akka 端口（Worker 通信）

访问 http://<host>:7700/#/powerjobLogin，默认 ADMIN / powerjob_admin。

3.2 PostgreSQL 后端

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


docker run -d \
 --restart=always \
 --name powerjob \
 --network=host \
 -e TZ="Asia/Shanghai" \
 -e JVMOPTIONS="" \
 -e PARAMS="--spring.profiles.active=product \
 --spring.datasource.core.driver-class-name=org.postgresql.Driver \
 --spring.datasource.core.jdbc-url=jdbc:postgresql://pg.internal.example.com:5432/chemistry_test?currentSchema=powerjob&stringtype=unspecified \
 --spring.datasource.core.username=postgres \
 --spring.datasource.core.password={{REDACTED}} \
 --spring.datasource.remote.hibernate.properties.hibernate.dialect=tech.powerjob.server.persistence.config.dialect.PowerJobPGDialect \
 --oms.http.port=10010 --server.port=7700 --oms.akka.port=10086" \
 -v /home/docker/powerjob-server:/root/powerjob/server \
 internal.example.com/base/powerjob/powerjob-server:5.1.2

关键：PG 模式必须显式指定 driver-class-name=org.postgresql.Driver + PowerJobPGDialect。

3.3 K8s 部署

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58


kind: ConfigMap
apiVersion: v1
metadata:
 name: powerjob-config
 namespace: <ns>
data:
 application-product.properties: |-
 oms.env=PRODUCT
 spring.datasource.core.driver-class-name=org.postgresql.Driver
 spring.datasource.core.jdbc-url=jdbc:postgresql://pg-host:5432/db?currentSchema=powerjob&stringtype=unspecified
 spring.datasource.core.username=postgres
 spring.datasource.core.password={{REDACTED}}
 spring.datasource.remote.hibernate.properties.hibernate.dialect=tech.powerjob.server.persistence.config.dialect.PowerJobPGDialect
 oms.instanceinfo.retention=7
 oms.container.retention.local=7
 oms.container.retention.remote=-1
 oms.instance.metadata.cache.size=2048
---
kind: Deployment
apiVersion: apps/v1
metadata:
 name: powerjob
 namespace: <ns>
spec:
 replicas: 1
 selector:
 matchLabels:
 app: powerjob
 template:
 metadata:
 labels:
 app: powerjob
 spec:
 containers:
 - name: powerjob
 image: internal.example.com/base/powerjob/powerjob-server:5.1.2
 env:
 - name: JVMOPTIONS
 value: -Dpowerjob.network.external.address=<external_ip> -Dpowerjob.network.external.port.http=30772
 - name: PARAMS
 value: --spring.profiles.active=product --server.port=30770 --oms.akka.port=30771 --oms.http.port=30772
 resources:
 limits: { cpu: 2, memory: 4Gi }
 requests: { cpu: 0.5, memory: 1000Mi }
---
kind: Service
apiVersion: v1
metadata:
 name: powerjob
 namespace: <ns>
spec:
 type: NodePort
 ports:
 - name: port30770 { port: 30770, targetPort: 30770, nodePort: 30770 }
 - name: port30771 { port: 30771, targetPort: 30771, nodePort: 30771 }
 - name: port30772 { port: 30772, targetPort: 30772, nodePort: 30772 }
 selector:
 app: powerjob

3.4 Worker 接入（Java 应用）

1
2
3
4
5


<dependency>
 <groupId>tech.powerjob</groupId>
 <artifactId>powerjob-worker</artifactId>
 <version>5.1.2</version>
</dependency>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


@Configuration
public class PowerJobWorkerConfig {
 @Bean
 public PowerJobWorker initWorker() throws Exception {
 PowerJobWorker worker = new PowerJobWorker();
 worker.setAppName("my-app");
 worker.setServerAddress("http://<powerjob_host>:10010");
 worker.setPort(28888); // Worker 端口
 worker.init();
 return worker;
 }
}

1
2
3
4
5
6
7
8


@Component
public class MyJob implements BasicProcessor {
 @Override
 public ProcessResult process(TaskContext ctx) {
 System.out.println("PowerJob run: " + ctx.getJobId());
 return new ProcessResult(true, "ok");
 }
}

JobProcessor 类型：

BasicProcessor：单任务处理

MapReduceProcessor：MapReduce 分布式计算

Workflow：工作流（多个 Job 串/并联）

3.5 字段类型修复（PG 模式）

PowerJob 的 instance_params / result 等字段默认用 PG 的 varchar(2000)，存大 JSON 会爆。迁移后执行：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


ALTER TABLE powerjob.instance_info ALTER COLUMN instance_params TYPE text USING instance_params::text;
ALTER TABLE powerjob.instance_info ALTER COLUMN "result" TYPE text USING "result"::text;
ALTER TABLE powerjob.job_info ALTER COLUMN job_params TYPE text USING job_params::text;
ALTER TABLE powerjob.workflow_info ALTER COLUMN pedag TYPE text USING pedag::text;
ALTER TABLE powerjob.workflow_instance_info ALTER COLUMN dag TYPE text USING dag::text;
ALTER TABLE powerjob.workflow_instance_info ALTER COLUMN "result" TYPE text USING "result"::text;
ALTER TABLE powerjob.workflow_instance_info ALTER COLUMN wf_context TYPE text USING wf_context::text;
ALTER TABLE powerjob.workflow_instance_info ALTER COLUMN wf_init_params TYPE text USING wf_init_params::text;
ALTER TABLE powerjob.workflow_node_info ALTER COLUMN extra TYPE text USING extra::text;
ALTER TABLE powerjob.workflow_node_info ALTER COLUMN node_params TYPE text USING node_params::text;

3.6 序列问题（MySQL → PG 迁移后）

MySQL 模式有 app_info 表的主键自增，迁到 PG 后序列不会自动绑定。修复：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


-- 1. 创建序列
CREATE SEQUENCE app_info_id_seq START WITH 1000 INCREMENT BY 1;

-- 2. 绑定到字段
ALTER TABLE app_info ALTER COLUMN id SET DEFAULT nextval('app_info_id_seq');
ALTER SEQUENCE app_info_id_seq OWNED BY app_info.id;

-- 3. 验证
SELECT column_name, column_default
FROM information_schema.columns
WHERE table_name = 'app_info' AND column_name = 'id';

3.7 升级

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


# 1. 拉新镜像
docker pull powerjob/powerjob-server:5.1.2
docker save powerjob/powerjob-server:5.1.2 > p.tar

# 2. 推送到内网仓库
docker tag powerjob/powerjob-server:5.1.2 internal.example.com/base/powerjob/powerjob-server:5.1.2
docker push internal.example.com/base/powerjob/powerjob-server:5.1.2

# 3. 滚动升级（K8s）
kubectl rollout restart deploy/powerjob -n <ns>

四、SonarQube vs PowerJob：选型对比

维度	SonarQube	PowerJob
起源	2007（SonarSource）	2019（阿里）
类型	代码质量平台	分布式任务调度
核心能力	静态扫描、安全漏洞、代码异味	定时任务、Workflow、MapReduce
后端	PostgreSQL / Oracle	MySQL / PostgreSQL
部署	Docker / k8s	Docker / k8s
触发	Jenkins / GitLab CI / GitHub Actions	Cron / API / 上游任务完成
适合	持续集成门禁	分布式定时任务

经验法则：

需要"代码扫描 + 阻断" → SonarQube
需要"分布式定时任务 + 工作流" → PowerJob（比 XXL-JOB 强，但用户量不如 XXL-JOB 多）

五、2024+ 视角补充

本文写于 2025-12，2026+ 期间 SonarQube / PowerJob 关键演进：

SonarQube 26.x LTS（2026）：AI CodeFix（基于 LLM 自动修复漏洞）从商业版下放到 Developer Edition；SAST（静态应用安全测试）从商业版下沉；SCA（软件成分分析）覆盖 SCA 1.5+ 漏洞库
SonarQube Server 改名定型（原 SonarQube 9.x → 10.x → 2025.x → 26.x 系列），企业版 26.x 强化 AI 安全 / 机密检测（Secret Detection 2.0）
PowerJob 6.x（2025-Q3）：内置 K8s 原生 Worker（不再依赖固定 IP 注册）、分布式工作流（DAG）3.0、MapReduce 性能优化（10x+）、Prometheus metrics 内置暴露（不需要 v2ray-exporter 那种外挂）
PowerJob vs XXL-JOB vs DolphinScheduler（2025 视角）：DolphinScheduler（Apache 顶级项目）补齐了"工作流 + 数据任务"短板，2025 起在大数据 / 离线数仓场景超越 PowerJob
SonarQube 替代品（2025+）：SonarCloud（SaaS）、CodeQL（GitHub 原生）、Snyk Code、Codacy——AI 时代静态扫描工具百花齐放

实战建议（2026 视角）：

传统 Java 微服务 → SonarQube 26.x + PowerJob 6.x 仍是稳态组合
AI / LLM 项目 → 静态扫描外，Prompt 注入检测 / 模型输出合规 类工具还在快速演化，未到稳态
大数据 / 离线数仓 → DolphinScheduler 优于 PowerJob（数据源集成更丰富）
CI/CD 集成 → SonarQube 26 与 GitHub Actions / GitLab CI 集成已经非常成熟

六、扩展阅读

SonarQube 官方仓库：github.com/SonarSource/sonarqube
SonarQube 文档：docs.sonarsource.com
SonarQube Scanner CLI：docs.sonarsource.com/sonarqube-server-analyzing
PowerJob 官方仓库：github.com/PowerJob/PowerJob
PowerJob 文档：www.yuque.com/powerjob
XXL-JOB 对比：github.com/xuxueli/xxl-job
DolphinScheduler：dolphinscheduler.apache.org

XXL-Job 分布式调度：可视化任务管理 + MySQL 初始化 + 容器化部署

Wed, 15 Nov 2023 00:00:00 +0800

XXL-Job 是国内最流行的分布式任务调度平台——替代 cron / ScheduledExecutorService 的核心组件。本篇把 Docker 化部署、MySQL 初始化、调度中心 / 执行器接入、告警通知整理清楚。

阅读对象：Java 后端 / 运维工程师 覆盖范围：XXL-Job 调度中心部署 + MySQL 初始化表结构 + 执行器注册 + 任务路由策略（轮询 / 故障转移 / 分片广播）+ 告警邮件 + docker-compose 完整集成

一、为什么需要分布式调度

传统定时任务的痛点：

单机 cron：服务器挂了任务就没了
ScheduledExecutorService：分布式下会重复执行（3 台机器都跑）
手动控制：凌晨 3 点被叫起来手动跑批

XXL-Job 的解决方案：

能力	说明
可视化管理	Web 端配置任务、查看日志、触发重跑
分布式执行	任务在多台执行器中只跑一次（通过路由策略）
任务分片	1 个任务广播到 10 台机器并行处理（10x 提速）
失败重试	自动重试 N 次，指数退避
告警通知	任务失败邮件 / 钉钉 / 飞书通知
GLUE 模式	Web 端直接写 Java / Shell / Python 脚本
任务依赖	父任务完成触发子任务（DAG）

When to use XXL-Job：

替代 crontab（跨服务器去重 + 可视化）

跑批任务（日终结算、数据归档）

第三方接口同步（每 5 分钟拉一次数据）

定时清理（30 天前的日志）

订单超时关闭（每分钟扫描一次）

二、架构原理

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


┌──────────────────┐ ┌──────────────────┐
│ 调度中心 (Admin) │◄──────────────►│ 执行器 (Executor)│
│ - 任务配置 │ 注册 │ - 业务服务 │
│ - 触发调度 │ │ - 接收任务 │
│ - 日志收集 │ │ - 执行回调 │
│ - 告警通知 │ │ │
└────────┬─────────┘ └──────────────────┘
 │
 ▼
 ┌──────────┐
 │ MySQL │
 │ (元数据) │
 └──────────┘

调度中心（Admin）：独立部署，Web 管理界面
执行器（Executor）：嵌入到业务服务里，通过 jar 包依赖
MySQL：存任务配置 / 执行日志 / 调度锁

核心协议：执行器启动时主动注册到调度中心；调度中心触发后通过 RPC 调执行器。

三、MySQL 初始化

3.1 下载 SQL 脚本

1
2


# XXL-Job 2.4.0 表结构
wget https://github.com/xuxueli/xxl-job/blob/2.4.0/doc/db/tables_xxl_job.sql

完整表结构：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36


CREATE DATABASE IF NOT EXISTS `xxl_job` DEFAULT CHARSET utf8mb4;

USE `xxl_job`;

SET NAMES utf8mb4;

CREATE TABLE `xxl_job_info` (
 `id` int(11) NOT NULL AUTO_INCREMENT,
 `job_group` int(11) NOT NULL COMMENT '执行器主键ID',
 `job_desc` varchar(255) NOT NULL,
 `add_time` datetime DEFAULT NULL,
 `update_time` datetime DEFAULT NULL,
 `author` varchar(64) DEFAULT NULL,
 `alarm_email` varchar(255) DEFAULT NULL,
 `schedule_type` varchar(50) NOT NULL DEFAULT 'NONE' COMMENT '调度类型',
 `schedule_conf` varchar(128) DEFAULT NULL COMMENT '调度配置',
 `misfire_strategy` varchar(50) NOT NULL DEFAULT 'DO_NOTHING',
 `executor_route_strategy` varchar(50) DEFAULT NULL,
 `executor_handler` varchar(255) DEFAULT NULL,
 `executor_param` varchar(512) DEFAULT NULL,
 `executor_block_strategy` varchar(50) DEFAULT NULL,
 `executor_timeout` int(11) NOT NULL DEFAULT '0',
 `executor_fail_retry_count` int(11) NOT NULL DEFAULT '0',
 `glue_type` varchar(50) NOT NULL COMMENT 'GLUE类型',
 `glue_source` mediumtext COMMENT 'GLUE源代码',
 `glue_remark` varchar(128) DEFAULT NULL,
 `glue_updatetime` datetime DEFAULT NULL,
 `child_jobid` varchar(255) DEFAULT NULL,
 `trigger_status` tinyint(4) NOT NULL DEFAULT '0',
 `trigger_last_time` bigint(13) NOT NULL DEFAULT '0',
 `trigger_next_time` bigint(13) NOT NULL DEFAULT '0',
 PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

-- 还有：xxl_job_log, xxl_job_log_report, xxl_job_logglue, xxl_job_registry,
-- xxl_job_group, xxl_job_user, xxl_job_lock

8 张表：

表名	作用
`xxl_job_info`	任务配置
`xxl_job_log`	任务执行日志
`xxl_job_log_report`	日志报表
`xxl_job_logglue`	GLUE 源码历史
`xxl_job_registry`	执行器注册表
`xxl_job_group`	执行器分组
`xxl_job_user`	调度中心用户
`xxl_job_lock`	分布式锁

3.2 初始化用户

执行完 SQL 后，默认账号：admin / 123456（生产必改！）

四、调度中心部署

4.1 拉取镜像

1

docker pull xuxueli/xxl-job-admin:2.4.0

4.2 启动容器

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


docker run -d --restart=always --name xxl-job-admin \
 --net=host \
 -v /home/docker/xxl-job/data:/data \
 -e PARAMS=" \
 --spring.datasource.url=jdbc:mysql://10.0.1.1:3306/xxl_job?useUnicode=true&characterEncoding=UTF-8&autoReconnect=true&serverTimezone=Asia/Shanghai \
 --spring.datasource.username=root \
 --spring.datasource.password={{DB_PASS}}" \
 -e JAVA_OPTS="-Xms2g -Xmx2g -Xmn1g -Xss1m \
 -XX:SurvivorRatio=8 \
 -XX:MetaspaceSize=256m \
 -XX:MaxMetaspaceSize=256m \
 -XX:NativeMemoryTracking=detail" \
 xuxueli/xxl-job-admin:2.4.0

关键参数：

--net=host：管理端口 8080 直接暴露
PARAMS：MySQL 连接信息
JAVA_OPTS：JVM 调优
数据卷 /data 持久化日志

4.3 访问调度中心

1
2


http://<IP>:8080/xxl-job-admin
默认账号：admin / 123456

4.4 docker-compose 完整版

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


version: "3"
services:
 mysql:
 image: mysql:8.0
 container_name: xxl-job-mysql
 restart: always
 environment:
 MYSQL_ROOT_PASSWORD: {{DB_ROOT_PASS}}
 volumes:
 - /home/xxl-job/mysql:/var/lib/mysql
 command: --default-authentication-plugin=mysql_native_password

 xxl-job-admin:
 image: xuxueli/xxl-job-admin:2.4.0
 container_name: xxl-job-admin
 restart: always
 depends_on:
 - mysql
 ports:
 - "8080:8080"
 volumes:
 - /home/xxl-job/logs:/data/applogs
 environment:
 PARAMS: >
 --spring.datasource.url=jdbc:mysql://mysql:3306/xxl_job?useUnicode=true&characterEncoding=UTF-8
 --spring.datasource.username=root
 --spring.datasource.password={{DB_ROOT_PASS}}
 JAVA_OPTS: "-Xms1g -Xmx1g"

首次启动：

启动 MySQL 容器
手动导入 tables_xxl_job.sql
启动 xxl-job-admin

五、执行器接入（业务服务）

5.1 添加依赖

1
2
3
4
5


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

5.2 配置 application.yml

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


xxl:
 job:
 admin:
 addresses: http://xxl-job-admin.internal.example.com:8080/xxl-job-admin
 executor:
 appname: my-service
 address:
 ip:
 port: 9999
 logpath: /app/logs/xxl-job/jobhandler
 logretentiondays: 30
 accessToken: {{XXL_JOB_TOKEN}}

5.3 写任务 Handler

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


@Component
@JobHandler(value = "demoJobHandler")
public class DemoJobHandler extends IJobHandler {

 @Override
 public ReturnT<String> execute(String param) throws Exception {
 // 业务逻辑
 log.info("XXL-JOB Hello, param: {}", param);
 return ReturnT.SUCCESS;
 }
}

或者注解方式：

1
2
3
4
5


@XxlJob("myJobHandler")
public ReturnT<String> myJobHandler() throws Exception {
 // 业务逻辑
 return ReturnT.SUCCESS;
}

5.4 启动服务

业务服务启动时自动注册到调度中心，30 秒内在 Admin 后台 → 执行器管理看到。

六、任务配置

6.1 创建执行器

Admin → 执行器管理 → 新增：

1
2
3
4


AppName：my-service
名称：我的服务
注册方式：自动注册
机器地址：（自动填入）

6.2 创建任务

Admin → 任务管理 → 新增：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


执行器：my-service
任务描述：每日订单结算
调度类型：CRON
Cron：0 0 2 * * ? # 每天凌晨 2 点
运行模式：BEAN
JobHandler：demoJobHandler
路由策略：第一个
阻塞处理策略：单机串行
失败重试：3 次
告警邮件：ops@example.com

6.3 路由策略详解

策略	行为	适用
第一个	固定选第一台	任务不能并行
轮询	1→2→3→1→2→3	负载均衡
随机	随机选一台	简单场景
一致性 HASH	同参数同机器	分片场景
最不经常使用	选使用最少的	性能均衡
故障转移	失败后切下一台	高可用
忙碌转移	跳过忙碌选空闲	实时任务
分片广播	所有机器都跑	并行处理

6.4 分片广播实战

场景：10 万条订单待结算，1 台机器跑要 1 小时。

配置：

1

路由策略：分片广播

代码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


@XxlJob("settleOrdersJobHandler")
public ReturnT<String> settleOrdersJobHandler() throws Exception {
 // 分片参数
 int shardIndex = XxlJobHelper.getShardIndex(); // 当前分片（0 ~ shardTotal-1）
 int shardTotal = XxlJobHelper.getShardTotal(); // 总分片数

 // 假设有 10 万条待结算订单
 int total = 100000;
 int pageSize = total / shardTotal + 1;
 int from = shardIndex * pageSize;
 int to = Math.min(from + pageSize, total);

 // 处理 [from, to) 范围的订单
 List<Order> orders = orderDao.findPending(from, to);
 for (Order order : orders) {
 settle(order);
 }

 return ReturnT.SUCCESS;
}

效果：

5 台执行器 → 每台处理 2 万条 → 5x 提速

七、GLUE 模式

Web 端直接写代码——不用改业务服务：

7.1 GLUE Java

任务管理 → 选任务 → GLUE IDE → 写 Java：

1
2
3
4
5
6
7
8


public class GlueJobHandler extends IJobHandler {
 @Override
 public ReturnT<String> execute(String param) throws Exception {
 // 直接写业务逻辑
 // 注意：只能用 JDK 内置类，第三方类用不了
 return ReturnT.SUCCESS;
 }
}

适用：临时脚本（数据修复、临时跑批）。

7.2 GLUE Shell

1
2
3


#!/bin/bash
echo "xxl-job: hello shell"
echo "参数：$1"

7.3 GLUE Python

1
2
3
4
5
6


#!/usr/bin/env python
# -*- coding: UTF-8 -*-
import os
import sys
print("xxl-job: hello python")
print("参数：", sys.argv[1])

7.4 GLUE PHP / Node.js

类似，不展开。

八、告警通知

8.1 邮件告警

任务配置：

1

告警邮件：ops@example.com

Admin application.yml：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


spring:
 mail:
 host: smtp.example.com
 port: 465
 username: noreply@example.com
 password: {{SMTP_PASS}}
xxl:
 job:
 triggerpool:
 fast:
 max: 200

8.2 钉钉告警

自定义告警实现：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


@Component
public class DingTalkJobAlarm implements JobAlarm {
 @Override
 public boolean doAlarm(XxlJobInfo info, XxlJobLog log) {
 // 调钉钉 Webhook
 String text = String.format("任务 [%s] 执行失败\n日志：%s", 
 info.getJobDesc(),
 log.getHandleMsg());
 DingTalk.send("{{DINGTALK_TOKEN}}", text);
 return true;
 }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


@Configuration
public class XxlJobConfig {
 @Bean
 public XxlJobSpringExecutor xxlJobExecutor() {
 XxlJobSpringExecutor executor = new XxlJobSpringExecutor();
 executor.setAdminAddresses("http://xxl-job-admin:8080/xxl-job-admin");
 executor.setAppname("my-service");
 executor.setJobAlarm(new DingTalkJobAlarm()); // 自定义告警
 return executor;
 }
}

九、监控与日志

9.1 任务执行日志

任务管理 → 选任务 → 操作 → 日志 → 看每次执行：

触发时间
执行结果（成功 / 失败 / 调度失败）
耗时
失败原因（堆栈）
重试次数

日志保留：xxl.job.executor.logretentiondays=30（默认 30 天）。

9.2 调度报表

Admin → 调度报表：

1
2


成功 / 失败 / 调度失败 / 总数
按日 / 周 / 月 聚合

实战用法：每周一看上周的报表，任务成功率 < 99% 就要查问题。

9.3 告警指标

接入 Prometheus（自定义 exporter）：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


@Aspect
@Component
public class XxlJobMetricsAspect {
 @Around("@annotation(com.xxl.job.core.handler.annotation.XxlJob)")
 public void track(ProceedingJoinPoint pjp) throws Throwable {
 long start = System.currentTimeMillis();
 try {
 pjp.proceed();
 Metrics.counter("xxl_job_success", "name", pjp.getSignature().getName()).increment();
 } catch (Exception e) {
 Metrics.counter("xxl_job_failure", "name", pjp.getSignature().getName()).increment();
 } finally {
 Metrics.timer("xxl_job_duration", "name", pjp.getSignature().getName())
 .record(System.currentTimeMillis() - start, TimeUnit.MILLISECONDS);
 }
 }
}

十、典型坑位

10.1 任务执行但 Admin 看不到日志

症状：执行器跑完了任务，Admin 端日志查询不到。

原因：执行器 xxl.job.executor.logpath 路径配置错误。

修复：

1
2
3
4


xxl:
 job:
 executor:
 logpath: /data/applogs/xxl-job/jobhandler  # 必须是绝对路径

容器内注意：路径要在挂载卷内（否则容器重启日志丢）。

10.2 任务调度延迟

症状：任务应该 2 点跑，实际 2:05 才跑。

原因：

调度中心集群只 1 台，单点压力
任务太多（> 1000 个），调度中心处理不过来

修复：

调度中心集群部署
减少短间隔任务（每分钟 1 次的太多）
加大 xxl.job.triggerpool.fast.max

10.3 任务重复执行

症状：1 个任务在 2 台机器都跑了。

原因：路由策略选错（**不能用"分片广播"**用于只能跑 1 次的任务）。

修复：选 故障转移 或 第一个（默认）。

10.4 GLUE 模式不能用第三方类

修复：

1
2


GLUE Java 只能用 JDK 内置类
要用 Spring Bean，注解 @XxlJob

十一、生产部署清单

11.1 调度中心高可用

两台调度中心集群：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


# 调度中心 1
xxl-job-admin:
 ports: 8080
 environment:
 PARAMS: "--xxl.job.accessToken={{TOKEN}}"

# 调度中心 2
xxl-job-admin:
 ports: 8080
 environment:
 PARAMS: "--xxl.job.accessToken={{TOKEN}}"

执行器配置 2 个地址：

1
2
3
4


xxl:
 job:
 admin:
 addresses: http://admin1:8080/xxl-job-admin,http://admin2:8080/xxl-job-admin

任务触发时会轮询选一个调度中心。

11.2 数据库高可用

1
2
3
4
5
6


# MySQL 主从 + 读写分离
spring:
 datasource:
 url: jdbc:mysql://mysql-primary:3306/xxl_job
 # 读流量大的话可加：
 # url: jdbc:mysql:loadbalance://mysql-primary:3306,mysql-replica:3306/xxl_job

11.3 监控

Prometheus 抓 Admin metrics
告警规则：
- 任务失败率 > 5% → 告警
- 调度延迟 > 5 分钟 → 告警
- 调度中心内存 > 80% → 告警

十二、完整 docker-compose

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36


version: "3.8"
services:
 mysql:
 image: mysql:8.0
 container_name: xxl-job-mysql
 restart: always
 environment:
 MYSQL_ROOT_PASSWORD: {{DB_ROOT_PASS}}
 volumes:
 - /home/xxl-job/mysql:/var/lib/mysql
 networks:
 - xxl-net

 xxl-job-admin:
 image: xuxueli/xxl-job-admin:2.4.0
 container_name: xxl-job-admin
 restart: always
 depends_on:
 - mysql
 ports:
 - "8080:8080"
 volumes:
 - /home/xxl-job/logs:/data/applogs
 environment:
 PARAMS: >
 --spring.datasource.url=jdbc:mysql://mysql:3306/xxl_job?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai
 --spring.datasource.username=root
 --spring.datasource.password={{DB_ROOT_PASS}}
 --xxl.job.accessToken={{XXL_JOB_TOKEN}}
 JAVA_OPTS: "-Xms1g -Xmx1g -XX:+UseContainerSupport -XX:MaxRAMPercentage=75.0"
 networks:
 - xxl-net

networks:
 xxl-net:
 driver: bridge

十三、最佳实践清单

MySQL 8.0 + utf8mb4——中文支持好
调度中心至少 2 台集群——避免单点
路由策略根据场景选：
- 跑批任务 → 故障转移（高可用）
- 同步任务 → 分片广播（并行）
- 普通定时 → 第一个（避免重复）
告警邮件必开——失败 5 分钟内收到
任务日志保留 30 天——logretentiondays=30
失败重试 3 次——临时网络抖动不报错
执行器 ip+port 唯一——xxl.job.executor.ip 显式指定
GLUE 用于临时脚本——生产任务用 @XxlJob 注解
JVM 调优：UseContainerSupport + MaxRAMPercentage
任务配置备份：MySQL 定期 dump

2024+ 视角补充

本文写于 2023-11，2024-2026 期间 XXL-Job / 分布式调度生态关键演进：

XXL-Job 2.4+ → 2.5+（2024-2025）：Spring Boot 3.x 兼容；JDK 17 强制；K8s 原生调度（不再依赖固定 IP）
XXL-Job 2.5+：内置 OpenTelemetry 集成；Web IDE 增强（GLUE Java 支持 Spring Bean）
PowerJob 5.x（2024-2025）：K8s 原生 Worker（动态注册）；DAG 工作流 2.0；MapReduce 性能 10x——vs XXL-JOB 更现代
DolphinScheduler 3.2+（2024-2026）：Apache 顶级项目；大数据集成（Spark / Flink / Hive）；K8s 调度原生；多租户 + 工作流 3.0
Airflow 2.10+（2024-2026）：Python 系首选；TaskFlow API（Pythonic DAG）；Kubernetes Executor 2.0
Temporal 1.25+（2024-2026）：Workflow-as-Code 之王——状态机 + 长期运行任务首选
KubeVela 1.10+：云原生应用编排——微服务编排 + 灰度发布
Serverless Cron：AWS EventBridge Scheduler / 阿里云定时任务 / GCP Cloud Scheduler 2024+ 仍是云端首选

实战建议（2025-2026 视角）：

Java 业务定时任务 → XXL-Job 2.5+（轻量、上手快）或 PowerJob 5.x（更现代）
大数据 / 离线数仓 → DolphinScheduler 3.2+（Apache 顶级项目）
Python 系 → Airflow 2.10+
复杂工作流 / 长期任务 → Temporal 1.25+（2024-2026 趋势）
Serverless / 简单定时 → 云厂商 EventBridge / 定时任务

下一步

想看 JDK 自建镜像实战（Alpine / Debian / Ubuntu）→ JDK 自建镜像实战
想看 Java 应用 Docker 化（Tomcat / Spring Boot 打包）→ Java 应用 Docker 化
想看 Java 微服务治理（Sentinel 限流 / Spring Boot Admin）→ Java 微服务治理
想看 Nginx 自建镜像实战（反代安全加固）→ Nginx 自建镜像实战

PowerJob 分布式任务调度实战：可视化控制台 + 容器化部署 + 故障转移

Fri, 20 Sep 2019 00:00:00 +0800

PowerJob 分布式任务调度实战：可视化控制台 + 容器化部署 + 故障转移

背景与价值

分布式任务调度是后端系统的"水电煤"——定时报表、订单关闭、数据同步、对账、清理、推送都依赖它。Java 生态对比：

框架	维护方	特性	适合
Quartz	Terracotta	老牌单体，集群需自己实现	传统企业单体应用
XXL-Job	大众点评	经典分布式，轻量	中小型项目
Elastic-Job	当当 + Apache	生态丰富，依赖 ZK	大型分布式
PowerJob	QQ 音乐	新一代，多语言，Workflow	复杂业务编排
Spring Schedule	Spring	简单，但无分布式	单机

本文聚焦 PowerJob V4.3.9（2024-03 GA），最大的卖点是"可视化工作流"——可以用 DAG 编排多作业的复杂依赖关系，比 XXL-Job 的"作业依赖"更强大。

核心架构

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


┌────────────────────────────────────────┐
│ PowerJob Server │
│ (调度中心，端口 7700 HTTP / 10010 OMS)│
│ ┌──────────┐ ┌──────────┐ ┌────────┐ │
│ │ 调度器 │ │ 执行器 │ │ 控制台 │ │
│ └─────┬────┘ └─────┬────┘ └────┬───┘ │
└────────┼────────────┼──────────┼──────┘
 │ │ │
 ↓ ↓ ↓
┌────────────────────────────────────────┐
│ Worker 集群 │
│ ┌──────┐ ┌──────┐ ┌──────┐ │
│ │Worker│ │Worker│ │Worker│ │
│ │ 1 │ │ 2 │ │ 3 │ │
│ └──────┘ └──────┘ └──────┘ │
└────────────────────────────────────────┘
 ↓
 MySQL（持久化）

三大组件：

Server：调度中心，1 个或 3 节点集群
Worker：业务执行器，部署在业务应用内
MySQL：存储任务定义 + 执行历史

Server 部署

1. 初始化数据库

1
2
3
4
5
6
7


# 1. 创建数据库
mysql -u root -p{{MYSQL_PASSWORD}} -e \
 "CREATE DATABASE powerjob CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;"

# 2. 初始化表结构
# https://github.com/PowerJob/PowerJob/blob/v4.3.9/others/powerjob-mysql.sql
mysql -u root -p{{MYSQL_PASSWORD}} powerjob < powerjob-mysql.sql

2. Docker Compose 一键部署（推荐）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


# docker-compose.yml
version: '3'
services:
 powerjob-server:
 image: powerjob/powerjob-server:V4.3.9
 container_name: powerjob
 restart: always
 network_mode: host
 environment:
 - TZ=Asia/Shanghai
 - PARAMS=--spring.profiles.active=product \
 --spring.datasource.core.jdbc-url=jdbc:mysql://{{MYSQL_HOST}}:3306/powerjob?useUnicode=true&characterEncoding=UTF-8 \
 --spring.datasource.core.username={{DB_USER}} \
 --spring.datasource.core.password={{DB_PASSWORD}} \
 --oms.http.port=10010 \
 --server.address={{SERVER_IP}}
 volumes:
 - /data/powerjob-server:/root/powerjob/server
 - ~/.m2:/root/.m2

1

docker-compose up -d

3. 端口规划

端口	用途
7700	HTTP 服务（控制台 + API）
10010	OMS（运维管理）
10086	Akka 节点间通信（集群）

4. 控制台访问

1

http://{{SERVER_IP}}:7700

默认账号：内置 admin（首次登录强制改密）。

Worker 集成（业务应用）

1. 引入依赖

1
2
3
4
5


<dependency>
 <groupId>tech.powerjob</groupId>
 <artifactId>powerjob-worker-spring-boot-starter</artifactId>
 <version>4.3.9</version>
</dependency>

2. application.yml

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


powerjob:
 worker:
 enabled: true
 allow-lazy-connect-server: false # 启动时立即连 Server
 port: 9988
 app-name: my-application  # 必须与 Server 中注册的应用名一致
 server-address: {{SERVER_HOST}}:7700
 protocol: http
 store-strategy: disk  # 上下文存储：disk / memory
 max-result-length: 4096
 max-appended-wf-context-length: 4096

3. 注册应用（关键步骤）

首次启动 Worker 前必须先在 Server 控制台注册应用：

1
2


应用名：my-application # 与 worker 配置的 app-name 一致
密码：{{APP_SECRET}} # 自定义

否则 Worker 启动会报"应用未注册"。

4 大处理器类型

1. BasicProcessor（基础，单机执行）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


@Component
public class SimpleJob implements BasicProcessor {

 @Override
 public ProcessResult process(TaskContext context) throws Exception {
 String jobParams = context.getJobParams(); // 任务参数
 long instanceId = context.getInstanceId(); // 实例 ID
 log.info("任务执行: instanceId={}, params={}", instanceId, jobParams);

 // 返回执行结果
 return new ProcessResult(true, "执行成功 " + System.currentTimeMillis());
 }
}

2. BroadcastProcessor（广播，所有 Worker 都执行一次）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


@Component
public class ClearCacheJob implements BroadcastProcessor {

 @Override
 public ProcessResult broadcast(TaskContext context) {
 log.info("清理本地缓存");
 localCache.clear();
 return new ProcessResult(true);
 }
}

典型场景：每台机器本地缓存清理、每台机器配置刷新。

3. MapProcessor（分片，多 Worker 并行执行）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


@Component
public class BatchInsertJob implements MapProcessor {

 @Override
 public ProcessResult process(TaskContext context) {
 // 当前分片参数
 int subTaskId = (int) Thread.currentThread().getId();
 int totalSubTask = context.getControlPoint(); // 总分片数

 // 假设有 100 万条数据要处理
 int pageSize = 10000;
 int totalPage = 100;
 int startPage = subTaskId * (totalPage / totalSubTask);
 int endPage = (subTaskId + 1) * (totalPage / totalSubTask);

 for (int p = startPage; p < endPage; p++) {
 List<User> users = userDao.findByPage(p, pageSize);
 // 批量处理
 }

 return new ProcessResult(true, "处理 " + (endPage - startPage) + " 页");
 }
}

典型场景：百万级数据批量同步、并行处理。

4. MapReduceProcessor（分片 + 汇总）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


@Component
public class StatisticsJob implements MapReduceProcessor {

 // 1. Map 阶段：每台 Worker 算自己分区
 @Override
 public ProcessResult process(TaskContext context) {
 List<Order> orders = orderDao.findByDateRange(...);
 long totalAmount = orders.stream().mapToLong(Order::getAmount).sum();
 return new ProcessResult(true, String.valueOf(totalAmount));
 }

 // 2. Reduce 阶段：汇总所有 Worker 结果
 @Override
 public ProcessResult reduce(TaskContext context, List<TaskResult> taskResults) {
 long total = 0;
 for (TaskResult r : taskResults) {
 total += Long.parseLong(r.getResult());
 }
 log.info("总销售额: {}", total);
 return new ProcessResult(true, "Total: " + total);
 }
}

典型场景：分布式统计、跨节点数据汇总。

6 种时间表达式

PowerJob 支持 6 种 cron-like 触发方式：

类型	配置	例子
Cron	`0 0 2 * * ?`	每天凌晨 2 点
固定频率	`60000`	每 60 秒（毫秒）
固定延迟	`3000`	上次执行完后等 3 秒
API 触发	手动	运维控制台点击"执行一次"
工作流	DAG 编排	任务 A 完成后触发 B
OpenAPI	HTTP 触发	通过 API 远程触发

Cron 例子

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


# 每天凌晨 2 点
time_expression: "0 0 2 * * ?"

# 每周一上午 9 点
time_expression: "0 0 9 ? * 2"

# 每 5 分钟
time_expression: "0 */5 * * * ?"

# 每月 1 号零点
time_expression: "0 0 0 1 * ?"

Workflow（DAG 工作流）

PowerJob 相对 XXL-Job 的最大优势——可视化 DAG 编排。

1. 在控制台创建工作流

1
2
3


[开始] → [拉取数据] → [清洗] → [转换] → [入库] → [结束]
 ↓
 [推送通知]

2. 工作流节点配置

每个节点对应一个 Processor，可设置：

失败重试次数：0 / 1 / 3
跳过条件：前置任务 X 失败时跳过
并发度：1 / 5 / 10

3. 实战场景

1
2
3
4
5
6


订单超时关闭工作流：
1. 扫描超时订单（每 5 分钟）
2. 关闭订单
3. 释放库存
4. 退款
5. 发送通知

故障转移与容错

1. 任务超时

1
2
3
4
5


powerjob:
 worker:
 task-retry-num: 3 # 失败重试 3 次
 instance-retry-num: 0 # 实例不重试
 instance-time-limit: 0 # 0 = 不限时

2. 节点宕机

Worker 节点宕机后，Server 自动将任务重新派发到其他 Worker，无需人工介入。

3. 集群高可用

Server 3 节点集群 + MySQL 持久化：

1
2
3
4
5
6
7
8


# node-1
- PARAMS=--spring.profiles.active=product --oms.http.port=10010 --server.address=10.0.0.1

# node-2
- PARAMS=--spring.profiles.active=product --oms.http.port=10010 --server.address=10.0.0.2

# node-3
- PARAMS=--spring.profiles.active=product --oms.http.port=10010 --server.address=10.0.0.3

3 节点通过 Akka 集群 选举 Leader（类似 ZK 选举），Leader 宕机 30s 内自动切换。

4. 报警

控制台支持配置告警：

邮件（spring.mail.*）
钉钉（Webhook）
企业微信（Webhook）
Webhook 自定义

与 XXL-Job 对比

维度	XXL-Job	PowerJob
UI	经典、简洁	现代 + 暗色主题 + DAG
任务类型	4 类（Bean / GLUE / Shell / Python）	4 类（Basic / Broadcast / Map / MapReduce）
工作流	简单父子依赖	DAG 可视化编排
容器支持	一般	K8s 友好（自带 Operator 计划中）
多语言	Java only	Java + Python + Shell + HTTP
集群	集群分片	Akka 集群 + 故障自动转移
上手难度	简单	中等

选型建议：

简单 CRON 任务：XXL-Job（轻量、上手快）
复杂业务编排：PowerJob（DAG 工作流、MapReduce）

实战坑

1. Worker 启动失败：应用未注册

1

ERROR: app not registered

解决：先在 Server 控制台 → 应用管理 → 注册应用 → app-name 必须与 powerjob.worker.app-name 一致。

2. 时区问题

1
2
3
4


# 容器必须设置时区
environment:
 - TZ=Asia/Shanghai
 - JAVA_OPTS=-Duser.timezone=Asia/Shanghai

否则 Cron 任务触发时间会差 8 小时。

3. 大量任务调度延迟

1
2


Server 默认单节点：1000 QPS 调度能力
3 节点集群：3000 QPS

如果任务量 > 10万/天，建议 Server 集群 + Worker 多实例。

4. 任务执行时间超过间隔

1

固定频率 60s 任务，但任务本身耗时 80s

PowerJob 默认跳过当前任务，等下个周期。如果需要"执行完再等 60s"，改用 fixed_delay 类型。

前置知识与下一步

前置：

Spring Boot 基础
Docker 基础
Cron 表达式

下一步：

用 Workflow 编排复杂业务（订单超时关闭流程）
集成告警到企业 IM（钉钉 / 企微）
监控：Prometheus + Grafana 抓取 PowerJob 指标

小结

PowerJob 是国产分布式任务调度的新一代标杆，核心优势：

DAG 工作流（可视化编排）—— 复杂业务一图胜千言
Map / MapReduce —— 大数据量场景天然支持
多语言 Worker（Java + Python + Shell + HTTP）—— 异构系统集成友好
故障自动转移 + Akka 集群 —— 生产可用性高

如果你的项目有 10+ 定时任务 + 复杂依赖关系，XXL-Job 已经不够用，建议直接上 PowerJob。

2024+ 视角：PowerJob V5 + K8s 适配 + AI 运维

PowerJob V5（2024-12 GA）关键变化

V5 全面拥抱 K8s：内置 K8s Operator 风格的 PowerJobWorker CRD
Akka 升级：Akka 2.6 → Pekko 1.0（Apache 顶级项目，Akka 改 License 后社区 fork）
存储后端可插拔：H2 / MySQL / PostgreSQL / 达梦 / 人大金仓，V5 起把"存储"从核心解耦
多租户：单个 Server 集群可承载多业务方，namespace 隔离
工作流 2.0：DAG 节点支持循环 + 条件分支 + 子工作流

K8s 部署的 2024+ 范式

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51


# powerjob-server.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
 name: powerjob-server
spec:
 replicas: 3
 selector:
 matchLabels:
 app: powerjob-server
 template:
 metadata:
 labels:
 app: powerjob-server
 spec:
 containers:
 - name: server
 image: powerjob/powerjob-server:V5.0.0
 ports:
 - containerPort: 7700
 - containerPort: 10010
 env:
 - name: PARAMS
 value: "--spring.profiles.active=product
 --spring.datasource.core.jdbc-url=jdbc:mysql://mysql:3306/powerjob
 --spring.datasource.core.username=powerjob
 --spring.datasource.core.password=${DB_PASSWORD}
 --oms.http.port=10010"
 - name: TZ
 value: Asia/Shanghai
 resources:
 requests:
 memory: "2Gi"
 cpu: "1000m"
 limits:
 memory: "4Gi"
 cpu: "2000m"
---
apiVersion: v1
kind: Service
metadata:
 name: powerjob-server
spec:
 type: ClusterIP
 selector:
 app: powerjob-server
 ports:
 - name: http
 port: 7700
 - name: oms
 port: 10010

Worker 集成 2024+ 升级

1
2
3
4
5


<dependency>
 <groupId>tech.powerjob</groupId>
 <artifactId>powerjob-worker-spring-boot-starter</artifactId>
 <version>5.0.0</version>
</dependency>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


powerjob:
 worker:
 enabled: true
 port: 9988
 app-name: my-application
 server-address: powerjob-server:7700
 protocol: http
 # V5 新增
 max-result-length: 8192
 store-strategy: disk
 # 健康检查
 health-check-interval: 30
 # 标签（V5 多租户）
 tag: production
 namespace: tenant-a

V5 工作流 2.0 实战

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29


# 订单超时关闭工作流（V5 新增循环节点）
nodes:
 - id: scan_orders
 type: Basic
 processor: scanTimeoutOrders

 - id: close_order
 type: Basic
 processor: closeOrder
 dependsOn: [scan_orders]

 - id: release_stock
 type: Basic
 processor: releaseStock
 dependsOn: [close_order]

 - id: refund
 type: Basic
 processor: refundOrder
 dependsOn: [release_stock]

 - id: notify_user
 type: Basic
 processor: sendNotification
 dependsOn: [refund]
 # V5 新增：失败重试 + 告警
 retryCount: 3
 alertEnabled: true
 alertChannels: [dingtalk, feishu]

2024+ 监控与告警

PowerJob V5 内置 Prometheus metrics 端点：

1
2
3
4
5
6
7
8
9


# application.yml（Server）
management:
 endpoints:
 web:
 exposure:
 include: health,info,prometheus
 metrics:
 tags:
 application: powerjob-server

Grafana Dashboard：

任务执行 P50 / P95 / P99 延迟
Worker 在线数 / 任务队列长度
DAG 节点完成率

2024+ 选型对比

任务调度	2024+ 适用
XXL-Job	简单 CRON 任务（< 50 个）
PowerJob V5	中大型项目 + DAG 工作流
Apache DolphinScheduler	大数据 ETL（Spark / Flink 集成）
Temporal	复杂长事务（> 1 天的 saga）
Airflow	Python 生态（数据科学）
Argo Workflows	K8s 原生 DAG（容器级任务）

2024+ 实战坑

Akka License 变化：Akka 2.7+ 改 BSL 协议（商业收费），PowerJob V5 改用 Apache Pekko——老项目升级要清 classpath
V5 默认存储改为外置：不再内置 H2 内存模式，必须配 MySQL/PG
多租户 namespace 隔离：V5 起 Worker 必须带 namespace 配置，否则启动失败
K8s 部署：Server 至少 2 副本（防止单点脑裂），但不要超过 5 副本（Akka 集群规模 5 最佳）

PowerJob V5 推荐组合

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


中型互联网业务（Java + Python 异构）
├── PowerJob Server V5 × 3 副本（K8s Deployment）
├── MySQL 8.4 LTS 存储（StatefulSet + 持久卷）
├── PowerJob Worker × N 副本（与应用一起跑）
│ ├── Java 微服务 Worker
│ ├── Python 数据同步 Worker（HTTP 类型）
│ └── Shell 清理任务 Worker
├── DAG 工作流编排业务（订单 / 报表 / 同步）
├── Prometheus + Grafana 监控
└── 告警：钉钉 + 飞书 + 企业微信

任务调度 on Liangweidong's blog

SonarQube + PowerJob：代码质量与分布式任务调度实战

一、SonarQube 部署

1.1 前置要求

1.2 拉取与启动

1.3 首次登录

1.4 汉化插件

二、sonar-scanner + Jenkins 集成

2.1 准备 sonar-scanner

2.2 Jenkins 全局工具配置

2.3 Jenkins 系统配置

2.4 Jenkinsfile pipeline

2.5 Java 项目 sonar-project.properties

2.6 JS / 前端项目

三、PowerJob 部署

3.1 启动 Server（MySQL 后端）

3.2 PostgreSQL 后端

3.3 K8s 部署

3.4 Worker 接入（Java 应用）

3.5 字段类型修复（PG 模式）

3.6 序列问题（MySQL → PG 迁移后）

3.7 升级

四、SonarQube vs PowerJob：选型对比

五、2024+ 视角补充

六、扩展阅读

XXL-Job 分布式调度：可视化任务管理 + MySQL 初始化 + 容器化部署

一、为什么需要分布式调度

二、架构原理

三、MySQL 初始化

3.1 下载 SQL 脚本

3.2 初始化用户

四、调度中心部署

4.1 拉取镜像

4.2 启动容器

4.3 访问调度中心

4.4 docker-compose 完整版

五、执行器接入（业务服务）

5.1 添加依赖

5.2 配置 application.yml

5.3 写任务 Handler

5.4 启动服务

六、任务配置

6.1 创建执行器

6.2 创建任务

6.3 路由策略详解

6.4 分片广播实战

七、GLUE 模式

7.1 GLUE Java

7.2 GLUE Shell

7.3 GLUE Python

7.4 GLUE PHP / Node.js

八、告警通知

8.1 邮件告警

8.2 钉钉告警

九、监控与日志

9.1 任务执行日志

9.2 调度报表

9.3 告警指标

十、典型坑位

10.1 任务执行但 Admin 看不到日志

10.2 任务调度延迟

10.3 任务重复执行

10.4 GLUE 模式不能用第三方类

十一、生产部署清单

11.1 调度中心高可用

11.2 数据库高可用

11.3 监控

十二、完整 docker-compose

十三、最佳实践清单

2024+ 视角补充

下一步

PowerJob 分布式任务调度实战：可视化控制台 + 容器化部署 + 故障转移

PowerJob 分布式任务调度实战：可视化控制台 + 容器化部署 + 故障转移

背景与价值

核心架构

Server 部署

1. 初始化数据库

2. Docker Compose 一键部署（推荐）

3. 端口规划

4. 控制台访问

2.5 Java 项目 `sonar-project.properties`