Tomcat on Liangweidong's blog

分布式限流实战：Nginx + Tomcat + Guava + Redis Lua

Wed, 15 Sep 2021 00:00:00 +0800

本文写于 2021 年 9 月——彼时 Sentinel 已经在阿里系大规模落地，但中小厂仍以"自研 + Redis Lua"为主流。

一、限流分层架构

限流不是"做一次就够"，需要从边缘到核心层层设防：

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


 ┌──────────┐
 用户请求 ───> │ CDN │ 第 1 层：CDN 限流（按地区/ISP）
 └────┬─────┘
 ▼
 ┌──────────┐
 │ Nginx │ 第 2 层：边缘网关限流（IP / 域名）
 └────┬─────┘
 ▼
 ┌──────────┐
 │ Tomcat │ 第 3 层：Web 容器限流（maxThreads）
 └────┬─────┘
 ▼
 ┌──────────┐
 │ 网关层 │ 第 4 层：Spring Cloud Gateway / Sentinel
 └────┬─────┘
 ▼
 ┌──────────┐
 │ 单体应用 │ 第 5 层：Guava RateLimiter
 └────┬─────┘
 ▼
 ┌──────────┐
 │ 分布式 │ 第 6 层：Redis + Lua 全局限流
 │ Redis │
 └──────────┘

核心思想：越靠近用户限流越粗（IP / 域名），越靠近业务限流越细（接口 / 用户）。

二、Nginx 限流（边缘网关层）

2.1 核心指令

Nginx 自带两个限流模块：

limit_req：限制请求速率（QPS）
limit_conn：限制并发连接数

2.2 完整配置

 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


# ===== 第一步：定义限流 zone（http 块）=====

# 根据 IP 限速：每秒 10 个请求
limit_req_zone $binary_remote_addr zone=iplimit:20m rate=10r/s;

# 根据 server 限速：每秒 1 个请求
limit_req_zone $server_name zone=serverlimit:10m rate=1r/s;

# 根据 IP 限并发：每个 IP 最多 100 个连接
limit_conn_zone $binary_remote_addr zone=perip:20m;

# 根据 server 限并发：每个 server 最多 100 个连接
limit_conn_zone $server_name zone=perserver:20m;

# ===== 第二步：在 location 应用 =====

server {
 server_name www.test.com;
 
 # 接口限流
 location /access-limit/ {
 proxy_pass http://127.0.0.1:8080/;
 
 # IP 限速（burst=2 允许瞬时 2 个排队，nodelay 不延迟立即处理）
 limit_req zone=iplimit burst=2 nodelay;
 # server 限速
 limit_req zone=serverlimit burst=2 nodelay;
 # IP 限并发 100
 limit_conn zone=perip 100;
 # server 限并发 100
 limit_conn zone=perserver 1;
 # 限流触发时返回 504（默认 503）
 limit_req_status 504;
 limit_conn_status 504;
 }
 
 # 限速下载
 location /download/ {
 # 前 100m 不限速
 limit_rate_after 100m;
 # 之后限速 256k/s
 limit_rate 256k;
 }
}

2.3 关键参数

burst=2：允许瞬时超出 rate 2 个请求排队等待
nodelay：排队不延迟，超出的请求立即返回 503（默认是延迟处理）
rate=10r/s：每秒 10 个请求（也支持 30r/m 每分钟 30 个）

三、Tomcat 限流（Web 容器层）

3.1 核心配置

Tomcat 8.5 通过 conf/server.xml 配置最大线程数：

1
2
3
4
5
6


<Connector port="8080"
 protocol="HTTP/1.1"
 connectionTimeout="20000"
 maxThreads="150" <!-- 最大线程数 -->
 acceptCount="100" <!-- 等待队列长度 -->
 redirectPort="8443" />

工作原理：

当并发请求 > maxThreads（默认 150）时，请求进入等待队列
等待队列满后，新请求被拒绝
天然限流

3.2 调优建议

小贴士：maxThreads 默认 150（Tomcat 8.5.42），但不是越大越好：

每开 1 个线程 → 1MB JVM 内存（线程栈）
线程越多 → GC 负担越重
OS 限制：Windows 每进程 ≤ 2000 线程，Linux 每进程 ≤ 1000 线程

经验值：8 核 16G 机器配 maxThreads=400 较合理，再多就是 GC 抖动的开始。

四、单体应用限流（Guava RateLimiter）

4.1 引入依赖

1
2
3
4
5
6


<!-- https://mvnrepository.com/artifact/com.google.guava/guava -->
<dependency>
 <groupId>com.google.guava</groupId>
 <artifactId>guava</artifactId>
 <version>31.1-jre</version>
</dependency>

4.2 简单使用

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


@Slf4j
@RestController
@RequestMapping("/limit")
public class LimitController {
 
 // 限流策略：1 秒钟 2 个请求
 private final RateLimiter limiter = RateLimiter.create(2.0);
 
 @GetMapping("/test1")
 public String testLimiter() {
 // 500 毫秒内，没拿到令牌就降级
 boolean tryAcquire = limiter.tryAcquire(500, TimeUnit.MILLISECONDS);
 
 if (!tryAcquire) {
 log.warn("进入服务降级，时间{}", LocalDateTime.now());
 return "当前排队人数较多，请稍后再试！";
 }
 
 log.info("获取令牌成功，时间{}", LocalDateTime.now());
 return "请求成功";
 }
}

4.3 Guava 限流模式

模式	类	特点
平滑突发（SmoothBursty）	`RateLimiter.create(permitsPerSecond)`	启动即可满速率
平滑预热（SmoothWarmingUp）	`RateLimiter.create(permitsPerSecond, warmupPeriod, unit)`	启动后有预热期，逐步提到配置速率

4.4 自定义注解 + AOP（接口级限流）

注解：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
@Documented
public @interface Limit {
 String key() default ""; // 资源 key
 double permitsPerSecond(); // QPS
 long timeout(); // 最大等待时间
 TimeUnit timeunit() default TimeUnit.MILLISECONDS;
 String msg() default "系统繁忙,请稍后再试.";
}

AOP 切面：

 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


@Slf4j
@Aspect
@Component
public class LimitAop {
 
 private final Map<String, RateLimiter> limitMap = Maps.newConcurrentMap();
 
 @Around("@annotation(com.example.limit.Limit)")
 public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
 MethodSignature signature = (MethodSignature) joinPoint.getSignature();
 Method method = signature.getMethod();
 Limit limit = method.getAnnotation(Limit.class);
 
 if (limit != null) {
 String key = limit.key();
 RateLimiter rateLimiter = limitMap.computeIfAbsent(
 key, k -> RateLimiter.create(limit.permitsPerSecond())
 );
 
 // 拿令牌
 boolean acquire = rateLimiter.tryAcquire(limit.timeout(), limit.timeunit());
 if (!acquire) {
 log.debug("令牌桶={}，获取令牌失败", key);
 this.responseFail(limit.msg());
 return null;
 }
 }
 return joinPoint.proceed();
 }
 
 private void responseFail(String msg) {
 HttpServletResponse response = ((ServletRequestAttributes) 
 RequestContextHolder.getRequestAttributes()).getResponse();
 ResultData<Object> resultData = ResultData.fail(ReturnCode.LIMIT_ERROR.getCode(), msg);
 WebUtils.writeJson(response, resultData);
 }
}

Controller：

1
2
3
4
5
6
7


@GetMapping("/test2")
@Limit(key = "limit2", permitsPerSecond = 1, timeout = 500, 
 timeunit = TimeUnit.MILLISECONDS, msg = "排队中，请稍候")
public String limit2() {
 log.info("limit2 获取令牌成功");
 return "ok";
}

4.5 IP 级限流

思路：每个 IP 一个 RateLimiter，缓存到 LoadingCache。

限流工具类：

 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


public class RateLimitUtil {
 /** 缓存：1000 个 IP，过期 1 天 */
 private static LoadingCache<String, RateLimiter> limitCaches = CacheBuilder.newBuilder()
 .maximumSize(1000)
 .expireAfterWrite(1, TimeUnit.DAYS)
 .build(new CacheLoader<String, RateLimiter>() {
 @Override
 public RateLimiter load(String key) {
 double perSecond = RateLimitUtil.getCacheKeyPerSecond(key);
 return RateLimiter.create(perSecond);
 }
 });
 
 /** 唯一 key = 资源名:ip:perSecond */
 public static String generateCacheKey(Method method, HttpServletRequest request) {
 RateLimit rateLimit = method.getAnnotation(RateLimit.class);
 StringBuilder cacheKey = new StringBuilder(rateLimit.name() + ":");
 cacheKey.append(getIpAddr(request) + ":");
 cacheKey.append(rateLimit.perSecond());
 return cacheKey.toString();
 }
 
 public static double getCacheKeyPerSecond(String cacheKey) {
 return Double.parseDouble(cacheKey.split(":")[2]);
 }
 
 public static String getIpAddr(HttpServletRequest request) {
 String ip = request.getHeader("x-forwarded-for");
 if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
 ip = request.getHeader("Proxy-Client-IP");
 }
 if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
 ip = request.getRemoteAddr();
 }
 // 多级代理取第一个 IP
 if (ip != null && ip.length() > 15) {
 if (ip.indexOf(",") > 0) {
 ip = ip.substring(0, ip.indexOf(","));
 }
 }
 return ip;
 }
}

五、分布式应用限流（Redis + Lua 令牌桶）

5.1 为什么需要 Redis 限流

Guava RateLimiter 是进程内的，集群部署时每个节点都有一份独立的限流器——比如 3 节点配 100 QPS，实际可能是 300 QPS。

Redis 限流 = 全集群共享一份限流计数。

5.2 令牌桶算法（Lua 实现）

 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


-- KEYS[1]: 接口唯一 ID
-- ARGV[1]: max_token（桶容量）
-- ARGV[2]: token_rate（每秒产生令牌数）
-- ARGV[3]: current_time（当前时间戳，毫秒）

local ratelimit_info = redis.pcall('HMGET', KEYS[1], 'last_time', 'current_token')
local last_time = ratelimit_info[1]
local current_token = tonumber(ratelimit_info[2])
local max_token = tonumber(ARGV[1])
local token_rate = tonumber(ARGV[2])
local current_time = tonumber(ARGV[3])

if current_token == nil then
 current_token = max_token
 last_time = current_time
else
 local past_time = current_time - last_time
 
 if past_time > 1000 then
 current_token = current_token + token_rate
 last_time = current_time
 end
 
 -- 防止溢出
 if current_token > max_token then
 current_token = max_token
 last_time = current_time
 end
end

local result = 0
if (current_token > 0) then
 result = 1
 current_token = current_token - 1
 last_time = current_time
end

redis.call('HMSET', KEYS[1], 'last_time', last_time, 'current_token', current_token)
return result

关键点：

每个接口的 key（如 uri:/api/order/create）对应一个 Hash
Hash 存 last_time（上次请求时间）+ current_token（当前桶内令牌数）
每隔 1000ms 自动补充 token_rate 个令牌
拿不到令牌返回 0，拿到了返回 1 并减 1

5.3 Spring Boot 集成

Redis 序列化配置：

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


@Bean(value = "redisTemplate")
@Primary
public RedisTemplate redisTemplate(RedisConnectionFactory factory) {
 RedisTemplate<String, Object> template = new RedisTemplate<>();
 template.setConnectionFactory(factory);
 
 ObjectMapper objectMapper = new ObjectMapper();
 objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
 
 StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
 Jackson2JsonRedisSerializer jsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
 jsonRedisSerializer.setObjectMapper(objectMapper);
 
 template.setKeySerializer(stringRedisSerializer);
 template.setHashKeySerializer(stringRedisSerializer);
 template.setValueSerializer(jsonRedisSerializer);
 template.setHashValueSerializer(jsonRedisSerializer);
 return template;
}

限流工具类：

 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


public class RedisLimiterUtils {
 
 private static StringRedisTemplate stringRedisTemplate = 
 ApplicationContextUtils.applicationContext.getBean(StringRedisTemplate.class);
 
 /**
 * 拿令牌
 * @param key 请求 ID（如接口 URI）
 * @param max 桶容量
 * @param rate 每秒生成令牌数
 * @return true=拿到，false=限流
 */
 public static boolean tryAcquire(String key, int max, int rate) {
 List<String> keyList = new ArrayList<>(1);
 keyList.add(key);
 
 DefaultRedisScript<Long> script = new DefaultRedisScript<>();
 script.setResultType(Long.class);
 script.setScriptText(LUA_SCRIPT);
 
 Long result = stringRedisTemplate.execute(
 script, keyList,
 Integer.toString(max),
 Integer.toString(rate),
 Long.toString(System.currentTimeMillis())
 );
 
 return Long.valueOf(1).equals(result);
 }
}

5.4 注解 + 拦截器

注解：

1
2
3
4
5
6
7


@Inherited
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface RateLimit {
 int capacity() default 100; // 桶容量
 int rate() default 10; // 每秒令牌数
}

拦截器：

 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


@Component
public class RateLimiterIntercept implements HandlerInterceptor {
 
 @Override
 public boolean preHandle(HttpServletRequest request, HttpServletResponse response,
 Object handler) throws Exception {
 if (handler instanceof HandlerMethod) {
 HandlerMethod handlerMethod = (HandlerMethod) handler;
 Method method = handlerMethod.getMethod();
 
 RateLimit rateLimit = AnnotationUtils.findAnnotation(method, RateLimit.class);
 if (Objects.isNull(rateLimit)) {
 rateLimit = AnnotationUtils.findAnnotation(
 handlerMethod.getBean().getClass(), RateLimit.class);
 }
 
 if (Objects.isNull(rateLimit)) return true;
 
 // 拿令牌，失败抛异常
 if (!RedisLimiterUtils.tryAcquire(
 request.getRequestURI(),
 rateLimit.capacity(),
 rateLimit.rate())) {
 throw new TimeOutException("系统繁忙，请稍后再试");
 }
 }
 return true;
 }
}

注册拦截器：

1
2
3
4
5
6
7
8


@Configuration
public class WebConfigurer implements WebMvcConfigurer {
 @Override
 public void addInterceptors(InterceptorRegistry registry) {
 registry.addInterceptor(new RateLimiterIntercept())
 .addPathPatterns("/**");
 }
}

六、4 种限流方案对比

维度	Nginx	Tomcat	Guava	Redis + Lua
粒度	IP / Server	容器线程	接口	接口 / 用户 / 全局
作用层	边缘	容器	单体应用	分布式
性能	极高	高	高	中（网络 IO）
跨节点	是	否	否	是
实现成本	配置	配置	引入 + AOP	Lua + 工具类
推荐场景	公网入口	单体应用	单体应用	分布式集群

七、面试常问

Q：令牌桶和漏桶有什么区别？ A：

令牌桶：以恒定速率生产令牌，请求消耗令牌。允许突发流量（桶满时能瞬时处理多个请求）
漏桶：以恒定速率流出请求，水（请求）任意速率流入桶。强制平滑，不允许突发

Q：为什么 Redis 限流要选 Lua 脚本？ A：Redis 单线程 + Lua 原子执行，整个限流判断在一次 RTT 内完成。如果用 Java 代码分多次调用（HMGET → 业务判断 → HMSET），中间被打断会导致计数错乱。

Q：Guava RateLimiter 和 Redis 限流怎么选？ A：

单实例 / 性能敏感：Guava（避免 Redis 网络 IO）
多实例 / 严格全局限流：Redis（保证全集群总和）

Q：Nginx 的 burst 和 nodelay 怎么理解？ A：burst=10 nodelay 表示允许 10 个请求瞬时超出 rate，但立即处理不排队。等价于"令牌桶初始有 10 个令牌，被拿完后必须等下一个令牌生成"。

八、小结

限流分层：CDN → Nginx → Tomcat → Gateway → 单体应用 → 分布式 Redis
Nginx：边缘限流首选，配置简单性能高
Tomcat：maxThreads 调优是基本功
Guava：单体内 AOP + 注解最优雅
Redis + Lua：分布式场景的必选，原子性 + 全局一致

Java 应用 Docker 化：Tomcat / Spring Boot 打包 + HTTPS / 时区 / 字体坑

Sat, 15 Dec 2018 00:00:00 +0800

Java 应用的 Docker 化比 Go / Node 麻烦得多——JVM、字体、时区、HTTPS 证书、Tomcat 配置每一个都是坑。本篇把"从 Spring Boot fat jar 到可生产的 Java 容器"完整流程整理清楚。

阅读对象：Java 后端 / 运维工程师 覆盖范围：Tomcat 镜像选型 + Spring Boot fat jar 打包 + anapsix/alpine-java 镜像使用 + HTTPS 证书导入 + 时区 / 中文乱码 / 字体 / DNS 解决 + 镜像瘦身 + 完整 docker-compose 部署

一、Java 容器化三大流派

1.1 流派对比

方案	镜像	体积	启动速度	适用
完整 JDK	`openjdk:8`	~ 800 MB	慢	需要 javac
JRE only	`openjdk:8-jre-slim`	~ 250 MB	中	生产应用
Alpine JRE	`anapsix/alpine-java:8u201b09_server-jre_nashorn`	~ 150 MB	快	生产首选
Native（GraalVM）	`ghcr.io/graalvm/native-image`	~ 50 MB	极快	性能要求高

默认推荐 anapsix/alpine-java——体积小、glibc 兼容好、社区维护。

1.2 为什么需要 alpine

alpine 镜像小 5x（musl libc vs glibc）
冷启动快：JVM 加载速度快 30%+
CVE 少：alpine 包更新频繁，CVE 修复更及时

二、Tomcat 镜像

2.1 官方 Tomcat 镜像

1
2
3
4
5


docker pull tomcat:8.5
docker run -d -p 8098:8080 \
 -v /data/my_tomcat_3/webapps:/usr/local/tomcat/webapps \
 --name my_tomcat_3 \
 tomcat:8.5

2.2 自建 Tomcat 镜像

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


# 1. 准备目录
mkdir tomcat_web && cd tomcat_web
touch Dockerfile start.sh

# 2. Dockerfile
cat > Dockerfile <<'EOF'
FROM tomcat:8.5
ADD ./webapps /usr/local/tomcat/webapps
CMD ["catalina.sh", "run"]
EOF

# 3. 构建
docker build -t tomcat_web:v2 .

# 4. 保存 / 加载（离线分发）
docker save -o tomcat_web.tar.gz tomcat_web:v2
docker load -i tomcat_web.tar.gz

2.3 完整 Tomcat 部署示例

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


# 创建工作目录
mkdir -p /home/epadmZZ && cd /home/epadmZZ
touch server.xml
mkdir logs ROOT

# 部署容器
docker run -tid --restart=always --name epadmZZ \
 -p 28081:8080 \
 -v /home/project/epadmZZ/:/Webs \
 -v /etc/localtime:/etc/localtime \
 -m 2048m --memory-swap=2048m --cpu-shares=256 \
 tomcat_web:v2 start.sh run -config /Webs/server.xml

关键参数：

-m 2048m --memory-swap=2048m：内存硬限——避免 OOM 影响宿主机
--cpu-shares 256：CPU 权重（默认 1024，相对值）
-v /etc/localtime:/etc/localtime：时区同步

三、Spring Boot fat jar 容器化

3.1 构建 Spring Boot 应用

1
2


mvn clean package
# 生成 target/myapp-1.0.0.jar

3.2 最小化 Dockerfile

1
2
3
4
5


FROM anapsix/alpine-java:8u201b09_server-jre_nashorn
VOLUME /tmp
ADD myapp-1.0.0.jar /app.jar
EXPOSE 8080
ENTRYPOINT ["java", "-jar", "/app.jar"]

3.3 启动参数注入

1
2
3
4
5
6
7
8


# 普通启动
docker run -d --restart=always \
 --name myapp \
 -p 8080:8080 \
 -v /home/project/myapp:/jar \
 -v /etc/localtime:/etc/localtime \
 anapsix/alpine-java:8u201b09_server-jre_nashorn \
 java -jar -Duser.timezone=GMT+08 /jar/myapp-1.0.0.jar

多端口 + 特殊权限（IoT 项目）：

1
2
3
4
5
6
7
8
9


docker run -d --restart=always \
 -v /home/project/iot:/jar \
 -v /home/project/iot/logs:/kde-iot-log \
 -v /etc/localtime:/etc/localtime \
 -p 8080:8080 -p 443:443 -p 18888:18888 \
 --net mynetwork --ip 172.18.0.5 \
 --privileged=true \
 --name iot anapsix/alpine-java:8u201b09_server-jre_nashorn \
 java -jar -Duser.timezone=GMT+08 /jar/iot-0.0.1-SNAPSHOT.jar

3.4 JVM 参数调优

1
2
3
4
5
6
7


docker run -d \
 -e JAVA_OPTS="-Xms2g -Xmx2g -Xmn1g -Xss1m \
 -XX:SurvivorRatio=8 \
 -XX:MetaspaceSize=256m \
 -XX:MaxMetaspaceSize=256m \
 -XX:NativeMemoryTracking=detail" \
 myapp:latest

容器内 JVM 调优要点：

JVM 看到的 CPU 数可能与宿主机不同——加 -XX:+UseContainerSupport（Java 10+）
JVM 看到的内存可能不准——加 -XX:MaxRAMPercentage=75.0
容器感知：java -XX:+PrintFlagsFinal -version | grep UseContainerSupport

1

ENV JAVA_OPTS="-XX:+UseContainerSupport -XX:MaxRAMPercentage=75.0 -XX:+PrintFlagsFinal"

四、HTTPS 证书导入

4.1 场景

小程序后台 + 数据接收 + 第三方 HTTPS 对接——需要 SSL 证书。

4.2 阿里云免费证书申请

1
2
3
4


1. 阿里云控制台 → SSL 证书 → 购买证书
2. 选择：单域名 / DV SSL / 免费版 / DigiCert
3. 域名验证（DNS 解析添加 TXT 记录）
4. 下载证书：Tomcat 类型（.pfx + password.txt）

4.3 PFX → JKS 转换

容器内 Java 用 JKS 格式：

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


# 1. 进入 JDK 容器
docker exec -it myapp bash

# 2. 找 keytool
which keytool
# /usr/lib/jvm/default-jvm/bin/keytool

# 3. 转换 PFX → JKS
keytool -importkeystore \
 -srckeystore /path/to/xxx.pfx \
 -destkeystore /app/wx.jks \
 -srcstoretype PKCS12 \
 -deststoretype JKS

# 4. 输入 PFX 密码（password.txt 中的密码）
# 5. 记好 alias（jks 文件别名）

4.4 挂载到容器

1
2
3


docker run -d \
 -v /home/project/wx.jks:/app/wx.jks \
 myapp:latest

4.5 Spring Boot 配置

1
2
3
4
5
6
7


server:
 port: 443
 ssl:
 key-store: classpath:wx.jks
 key-store-password: {{JKS_PASS}}
 key-store-type: JKS
 key-alias: alias

4.6 强制 HTTPS

 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


@SpringBootApplication
public class Application {

 @Bean
 public TomcatServletWebServerFactory servletContainer() {
 TomcatServletWebServerFactory tomcat = new TomcatServletWebServerFactory() {
 @Override
 protected void postProcessContext(Context context) {
 SecurityConstraint constraint = new SecurityConstraint();
 constraint.setUserConstraint("CONFIDENTIAL");
 SecurityCollection collection = new SecurityCollection();
 collection.addPattern("/*");
 constraint.addCollection(collection);
 context.addConstraint(constraint);
 }
 };
 tomcat.addAdditionalTomcatConnectors(httpConnector());
 return tomcat;
 }

 @Bean
 public Connector httpConnector() {
 Connector connector = new Connector("org.apache.coyote.http11.Http11NioProtocol");
 connector.setScheme("http");
 connector.setPort(8080);
 connector.setSecure(false);
 connector.setRedirectPort(443);
 return connector;
 }

 public static void main(String[] args) {
 SpringApplication.run(Application.class, args);
 }
}

效果：

80 / 8080 收到请求 → 自动 302 重定向到 443
443 走 HTTPS

五、时区问题

5.1 三种方法

方法 A：挂载宿主机时区（最简单）

1

docker run -v /etc/localtime:/etc/localtime:ro ...

方法 B：环境变量 TZ（Java 8u72+）

1

docker run -e TZ=Asia/Shanghai ...

方法 C：JVM 参数

1

java -Duser.timezone=GMT+08 -jar app.jar

生产推荐 A + B 一起用。

5.2 容器内修改

1
2
3
4
5
6


# 进入容器
docker exec -it 2c87bcc41378 /bin/bash

# 拷贝时区文件
cp /usr/share/zoneinfo/Asia/Shanghai /etc/localtime
echo "Asia/Shanghai" > /etc/timezone

alpine 镜像特殊处理：

1
2
3


RUN apk add --no-cache tzdata \
 && ln -sf /usr/share/zoneinfo/Asia/Shanghai /etc/localtime \
 && echo "Asia/Shanghai" > /etc/timezone

六、中文乱码

6.1 三处必设

Dockerfile / 启动参数：

1
2
3
4
5


java -Dfile.encoding=UTF-8 \
 -Dsun.jnu.encoding=UTF-8 \
 -Duser.language=zh \
 -Duser.country=CN \
 -jar app.jar

MySQL 连接串：

1
2
3


spring:
 datasource:
 url: jdbc:mysql://10.0.1.1:3306/mydb?useUnicode=true&characterEncoding=UTF-8

Linux locale（容器内）：

1
2
3
4
5
6
7


docker exec -it myapp locale
# 看到 POSIX / C 是错的

# 设置
docker exec -it myapp bash
localedef -i en_US -f UTF-8 en_US.UTF-8
export LANG=en_US.UTF-8

根治：

1
2


ENV LANG=C.UTF-8
ENV LC_ALL=C.UTF-8

七、字体问题

7.1 症状

Java 应用：

导出 PDF 中文变方块
生成图形验证码 OOM
POI 操作 Excel 报错

原因：JDK 本身不带字体，alpine / slim 镜像里 fontconfig 也没装。

7.2 修复

Debian / Ubuntu 基础：

1

RUN apt-get update && apt-get install -y fontconfig

Alpine 基础（alpine 3.15+ 必需）：

1

RUN apk add --no-cache fontconfig

完整中文字体（把 Windows 字体拷进容器）：

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


# 1. 宿主机准备字体目录
mkdir -p /home/fonts

# 2. 从 Windows 拷贝
# C:\Windows\Fonts\msyh.ttc (微软雅黑)
# C:\Windows\Fonts\simfang.ttf (仿宋)
# C:\Windows\Fonts\simhei.ttf (黑体)
# C:\Windows\Fonts\simsun.ttc (宋体)

# 3. 挂载到容器
docker run \
 -v /home/fonts:/usr/share/fonts/win \
 ...

容器内更新字体缓存：

1
2
3


docker exec -it myapp bash
fc-cache -fv
fc-list :lang=zh

7.3 Spring Boot PDF 字体

1
2
3
4
5
6
7
8
9


@Bean
public PdfReportFontConfig pdfFontConfig() {
 return new PdfReportFontConfig() {
 @Override
 public String getFontFile() {
 return "/usr/share/fonts/win/msyh.ttc";
 }
 };
}

八、容器化常用工具

8.1 必备工具清单

1
2
3
4
5


# Alpine 镜像（最小化，几乎啥都没有）
apk add --no-cache curl wget iputils-ping iproute2 bash vim fontconfig tzdata

# Debian 镜像
apt-get install -y curl wget iputils-ping iproute2 vim fontconfig dnsutils

8.2 容器内调试

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


# 进容器
docker exec -it myapp bash

# 看进程
ps -ef
ps aux

# 看端口
netstat -tnlp # alpine: apk add net-tools
ss -tnlp # 通用

# 看内存
free -h

九、DNS 问题

症状：容器内 ping internal.example.com 失败。

修复：

1
2
3
4
5
6
7
8
9


# 1. 修改 docker daemon DNS
vim /etc/docker/daemon.json
{
 "dns": ["114.114.114.114", "8.8.8.8"]
}
systemctl restart docker

# 2. 或容器内指定
docker run --dns 114.114.114.114 --dns 8.8.8.8 ...

十、镜像瘦身

10.1 多阶段构建

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


# 阶段 1：编译
FROM maven:3.9-eclipse-temurin-17 AS build
COPY pom.xml .
RUN mvn dependency:go-offline
COPY src ./src
RUN mvn clean package -DskipTests

# 阶段 2：运行时
FROM anapsix/alpine-java:8u201b09_server-jre_nashorn
COPY --from=build /target/myapp-1.0.0.jar /app.jar
EXPOSE 8080
ENTRYPOINT ["java", "-jar", "/app.jar"]

效果：编译镜像 ~ 800MB，运行时镜像 ~ 150MB。

10.2 清理缓存

1
2


RUN apt-get update && apt-get install -y fontconfig \
 && rm -rf /var/lib/apt/lists/* # 必须清！

10.3 JLink 定制 JRE

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


# 用 jlink 裁剪 JDK（Java 9+）
jlink \
 --module-path $JAVA_HOME/jmods \
 --add-modules java.base,java.logging,java.sql,java.naming,java.management,java.security.jgss,java.desktop \
 --output /opt/jre-mini \
 --strip-debug --no-man-pages --compress=2

# 用自定义 JRE 做基础镜像
FROM scratch
COPY --from=builder /opt/jre-mini /opt/jre
ENV JAVA_HOME=/opt/jre
ENV PATH=$JAVA_HOME/bin:$PATH

效果：JRE 50MB 级别。

十一、完整生产 Dockerfile

 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


# 阶段 1：构建
FROM maven:3.9-eclipse-temurin-17 AS build
WORKDIR /build
COPY pom.xml .
RUN mvn dependency:go-offline -B
COPY src ./src
RUN mvn clean package -DskipTests

# 阶段 2：运行时
FROM anapsix/alpine-java:8u201b09_server-jre_nashorn

# 必备工具
RUN apk add --no-cache \
 fontconfig \
 tzdata \
 tini \
 && cp /usr/share/zoneinfo/Asia/Shanghai /etc/localtime \
 && echo "Asia/Shanghai" > /etc/timezone \
 && fc-cache -fv

# JVM 容器感知
ENV JAVA_OPTS="-XX:+UseContainerSupport -XX:MaxRAMPercentage=75.0 -XX:+ExitOnOutOfMemoryError"

# 中文环境
ENV LANG=C.UTF-8 \
 LC_ALL=C.UTF-8 \
 TZ=Asia/Shanghai

WORKDIR /app
COPY --from=build /build/target/*.jar /app/app.jar

# 暴露端口
EXPOSE 8080

# tinit 收僵尸进程
ENTRYPOINT ["/sbin/tini", "--", "sh", "-c", "exec java $JAVA_OPTS -jar /app/app.jar"]

十二、典型坑位

12.1 容器里 `ping` 找不到

1

RUN apt-get install -y iputils-ping

12.2 容器里 `curl` / `wget` 找不到

1

RUN apt-get install -y curl wget

12.3 catalina.out 无限膨胀

1
2
3
4


# 清空
cat /dev/null > /opt/sxt/logs/catalina.out

# 配置 logrotate

12.4 DNS 解析失败

1
2


# 容器内
docker run --dns 114.114.114.114 ...

12.5 内存超限被 OOM

1
2
3
4
5


# 加硬限
docker run -m 2g --memory-swap=2g ...

# JVM 也限
java -Xmx1500m ...

十三、生产部署清单

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


# 1. 构建
docker build -t myapp:20240315 .

# 2. 保存离线
docker save -o myapp.tar.gz myapp:20240315

# 3. 推 Harbor
docker push myapp.example.com/library/myapp:20240315

# 4. 部署
docker run -d --restart=always \
 --name myapp \
 --net=mynetwork \
 -p 8080:8080 \
 -v /home/myapp/logs:/app/logs \
 -v /home/myapp/config:/app/config \
 -v /etc/localtime:/etc/localtime:ro \
 -m 2g --memory-swap=2g \
 myapp.example.com/library/myapp:20240315

# 5. 接入日志
docker logs -f myapp 2>&1 | tee -a /var/log/myapp/app.log

十四、最佳实践清单

JRE 镜像而非 JDK（生产不需要 javac）
anapsix/alpine-java 默认推荐（社区维护 + glibc 兼容）
-XX:+UseContainerSupport JVM 容器感知
-XX:MaxRAMPercentage=75.0 内存自适应
-XX:+ExitOnOutOfMemoryError OOM 退出（让编排系统重启）
tini 收僵尸进程（Java 不会自动 reap）
LANG=C.UTF-8 + 字体 解决中文乱码
/etc/localtime 挂载 解决时区
-m 2g --memory-swap=2g 硬限内存
多阶段构建 镜像瘦身

2024+ 视角补充

本文写于 2018-12，2024-2026 期间 Java 应用容器化关键演进：

JDK 17 / 21 主流化：JDK 8 官方支持 2024-03 已结束（最后 LTS）——新项目必须 JDK 17 或 21；JDK 21（2023-09 LTS，支持到 2031）已成 2024+ 主流
Spring Boot 3.2+ 全面 Jakarta EE：从 javax.* 迁移到 jakarta.*——Tomcat 10+ 是默认；JDK 17 最低要求
Spring Boot 3.4+（2025）：Virtual Threads（虚拟线程）默认集成——JDK 21 协程天然适配
GraalVM Native Image 1.0+（2024-2026）：Spring Boot 3.x 官方支持——spring-boot:build-image 直接生成 native 可执行文件，启动 < 100ms，内存 < 100MB
CRaC（Coordinated Restore at Checkpoint）：OpenJDK 17+ 实验，JVM 启动 < 10ms——Serverless / K8s 冷启动杀手
容器镜像生态：
- Eclipse Temurin（2024-2026）：前 Adoptium，JDK 21 主流发行版——OpenJDK + 商业支持
- BellSoft Liberica JDK（2024-2026）：Native Image Kit + Alpine glibc 兼容——容器首选
- Azul Zulu Prime（2024-2026）：C4 Pauseless GC——延迟敏感场景
- Amazon Corretto（2024-2026）：AWS 维护，生产级 LTS
多阶段构建 已成 Java 容器化标准
JLink 定制 JRE：50MB 级别运行时镜像

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

新项目 → JDK 21 LTS + Spring Boot 3.4+ + GraalVM Native Image（Serverless / 冷启动敏感场景）
存量项目 → 升 JDK 17 LTS（避免 JDK 8 / 11 停服）→ 再逐步升 21
Serverless / K8s 冷启动 → GraalVM Native Image 或 CRaC
基础镜像：BellSoft Liberica JDK 21 是 2024+ 容器首选

下一步

想看 JDK 自建镜像实战（Debian / Ubuntu / Alpine 三大流派）→ JDK 自建镜像实战
想看 Nginx 自建镜像实战（前端 dist / 反代）→ Nginx 自建镜像实战
想看 Java 微服务治理（Sentinel 限流 / Spring Boot Admin）→ Java 微服务治理
想看 XXL-Job 分布式调度（任务调度平台）→ XXL-Job 分布式调度