宿主机负责正式运行
Java 服务最终仍由 systemd 管理，监听固定的 48080 ，不改变现有 Nginx 配置。

Docker 只负责制作 CRaC 快照
新 JAR 在容器内冷启动、完成健康检查和预热，然后创建 checkpoint 。容器内部仍使用 48080 ，宿主机映射随机端口，所以不会和线上服务冲突。

容器和宿主机使用相同路径
统一挂载：
/opt/app-server/app-server.jar
/opt/app-server/zulu25-crac
/opt/app-server/crac/checkpoint
避免恢复时出现 JDK 、JAR 或快照路径不一致。

外部服务使用统一可达地址
MySQL 、Redis 、TDengine 等从 127.0.0.1 改成 172.17.0.1 ，保证容器制作快照和宿主机恢复后都能连接。

快照成功后再切换
Docker checkpoint 成功之前，旧服务继续运行。成功后才停止旧进程、替换 JAR 和快照，再由 systemd 从 checkpoint 快速恢复。

实测启动时间从 2 分钟压到了三秒
需要注意的是
1.crac 特性当前仅 linux 端可用
2.集成 crac,需要告诉它关闭连接的顺序，重启连接的顺序```

import com.alibaba.druid.pool.DruidDataSource;
import com.baomidou.dynamic.datasource.DynamicRoutingDataSource;
import com.baomidou.dynamic.datasource.ds.ItemDataSource;
import org.crac.Context;
import org.crac.Core;
import org.crac.Resource;
import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import org.springframework.context.ConfigurableApplicationContext;

import javax.sql.DataSource;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.IdentityHashMap;
import java.util.List;
import java.util.Set;

/**
* Coordinates external clients that are not managed by Spring's CRaC lifecycle support.
*
* <p>This resource is registered before the Spring application starts. Spring's resource
* is therefore called first before a checkpoint, pausing web, scheduling and messaging
* lifecycle beans. This resource then closes database and Redis connections. On restore,
* the connections are recreated before Spring restarts its lifecycle beans.</p>
*/
public final class CracApplicationContextResource implements Resource {

private static volatile CracApplicationContextResource instance;

private final List<RestartableRedissonClient> checkpointRedissonClients = new ArrayList<>();

private final List<DruidDataSource> checkpointDataSources = new ArrayList<>();

private volatile ConfigurableApplicationContext applicationContext;

private CracApplicationContextResource() {
}

public static synchronized CracApplicationContextResource register() {
if (instance != null) {
throw new IllegalStateException("CRaC application resource is already registered");
}
CracApplicationContextResource resource = new CracApplicationContextResource();
Core.getGlobalContext().register(resource);
instance = resource;
return resource;
}

public void attach(ConfigurableApplicationContext applicationContext) {
this.applicationContext = applicationContext;
}

@Override
public synchronized void beforeCheckpoint(Context<? extends Resource> context) {
ConfigurableApplicationContext currentContext = this.applicationContext;
if (currentContext == null) {
throw new IllegalStateException("Spring application context is not attached");
}

System.out.println("[CRaC] Suspending external clients before checkpoint");
this.checkpointRedissonClients.clear();
Set<RedissonClient> redissonClients = Collections.newSetFromMap(new IdentityHashMap<>());
redissonClients.addAll(currentContext.getBeansOfType(RedissonClient.class).values());
for (RedissonClient redissonClient : redissonClients) {
RestartableRedissonClient restartable = new RestartableRedissonClient(redissonClient);
this.checkpointRedissonClients.add(restartable);
}
for (RestartableRedissonClient redissonClient : this.checkpointRedissonClients) {
redissonClient.suspend();
}

this.checkpointDataSources.clear();
this.checkpointDataSources.addAll(findDruidDataSources(currentContext));
for (DruidDataSource dataSource : this.checkpointDataSources) {
dataSource.close();
}
System.out.println("[CRaC] External clients suspended");
}

@Override
public synchronized void afterRestore(Context<? extends Resource> context) throws SQLException {
System.out.println("[CRaC] Resuming external clients after restore");
for (DruidDataSource dataSource : this.checkpointDataSources) {
dataSource.restart();
dataSource.init();
}
for (RestartableRedissonClient redissonClient : this.checkpointRedissonClients) {
redissonClient.resume();
}
System.out.println("[CRaC] External clients resumed");
}

private static Set<DruidDataSource> findDruidDataSources(ConfigurableApplicationContext context) {
Set<DruidDataSource> result = Collections.newSetFromMap(new IdentityHashMap<>());
for (DynamicRoutingDataSource routingDataSource
: context.getBeansOfType(DynamicRoutingDataSource.class).values()) {
for (DataSource dataSource : routingDataSource.getDataSources().values()) {
DataSource candidate = dataSource;
if (candidate instanceof ItemDataSource itemDataSource) {
candidate = itemDataSource.getRealDataSource();
}
if (candidate instanceof DruidDataSource druidDataSource) {
result.add(druidDataSource);
}
}
}
return result;
}

private static final class RestartableRedissonClient {

private final RedissonClient client;

private final Config config;

private RestartableRedissonClient(RedissonClient redissonClient) {
if (!(redissonClient instanceof Redisson)) {
throw new IllegalStateException("Unsupported RedissonClient implementation: "
+ redissonClient.getClass().getName());
}
this.client = redissonClient;
this.config = new Config(redissonClient.getConfig());
}

private void suspend() {
this.client.shutdown();
}

private void resume() {
RedissonClient replacement = Redisson.create(new Config(this.config));
replaceRedissonState((Redisson) this.client, (Redisson) replacement);
}

private static void replaceRedissonState(Redisson target, Redisson source) {
try {
for (Field field : Redisson.class.getDeclaredFields()) {
if (Modifier.isStatic(field.getModifiers())) {
continue;
}
field.setAccessible(true);
field.set(target, field.get(source));
}
} catch (ReflectiveOperationException exception) {
source.shutdown();
throw new IllegalStateException("Unable to restore Redisson client state", exception);
}
}

}

}
``3.需要指定可能引用的文件位置 crac-resource-policies.yaml``
root@base:/opt/app-server# cat crac-resource-policies.yaml

Logback keeps the active application log open across checkpoint/restore.

type: file
path: /root/logs/app-server.log
action: reopen

RocketMQ uses its own file logger outside the Spring logging lifecycle.

type: file
path: /root/logs/rocketmqlogs/rocketmq_client.log
action: reopen

Java2D fonts loaded from streams are backed by persistent temporary files.

type: file
path: /opt/app-server/crac/tmp/+~JF*.tmp
action: reopen
root@base:/opt/app-server#
``启动命令类似``
root@base:/opt/app-server# cat /opt/app-server/run-app-server.sh
#!/usr/bin/env bash

set -Eeuo pipefail

APP_DIR="${APP_DIR:-/opt/app-server}"
APP_JAR="${APP_DIR}/app-server.jar"
CRAC_JAVA_HOME="${CRAC_JAVA_HOME:-${APP_DIR}/zulu25-crac}"
JAVA_BIN="${CRAC_JAVA_HOME}/bin/java"
IMAGE_DIR="${APP_DIR}/crac/checkpoint"
TMP_DIR="${APP_DIR}/crac/tmp"
POLICY_FILE="${APP_DIR}/crac-resource-policies.yaml"
PROFILE="${APP_PROFILE:-prod}"
APP_TIMEZONE="${APP_TIMEZONE:-Asia/Shanghai}"

install -d -m 700 "${IMAGE_DIR}" "${TMP_DIR}"
echo "[launcher] Trying CRaC restore from ${IMAGE_DIR}; falling back to a cold start when unavailable"
exec "${JAVA_BIN}" \
-server \
-Xms512m \
-Xmx1024m \
-XX:+HeapDumpOnOutOfMemoryError \
-XX:HeapDumpPath="${APP_DIR}/heapdump.hprof" \
-Duser.timezone="${APP_TIMEZONE}" \
-Djava.io.tmpdir="${TMP_DIR}" \
-Djdk.crac.resource-policies="${POLICY_FILE}" \
-XX:CRaCEngine=warp \
-XX:CRaCRestoreFrom="${IMAGE_DIR}" \
-XX:+CRaCIgnoreRestoreIfUnavailable \
-XX:CRaCCheckpointTo="${IMAGE_DIR}" \
-jar "${APP_JAR}" \
--spring.profiles.active="${PROFILE}"
```如果检查不到 checkpoint ，会保底从 jar 冷启动

去年没有 ai,折腾这一套没成功
今年有 codex 的帮助，crac 这一套快速启动的便捷性成功实现了
我的这一套只针对单体 springboot 程序
如果是 spring cloud 感觉会更受益，三秒容器上线