如何基于Docker构建可按需扩缩容的Java Spring多服务应用

嘿，这个需求我之前做类似项目时碰到过，咱们一步步拆解实现方案——核心思路就是把请求路由和服务执行的逻辑拆解开，这样才能单独给高负载的服务多分配Docker实例，同时保持对外只有一个REST端点的要求。

1. 先拆分应用组件 #

把原来的单块应用拆成两个独立部分：

• 请求网关（Gateway）：这是对外暴露的唯一REST入口，负责接收请求、解析参数里的服务标识，然后把请求转发到对应服务的实例池。这个组件本身压力不大，不用搞太多实例。
• 服务执行Worker：每个Worker实例只负责跑某一种服务的逻辑（比如一个Worker只处理Service A，另一个只处理Service C）。这样咱们就能精准控制每个服务的实例数量——需要5个实例的服务就启动5个Docker容器，需要1个的就只启动1个。

2. Worker实例的Docker化配置 #

给Worker做Docker镜像时，用环境变量指定它要运行的服务ID，这样同一个镜像就能生成对应不同服务的实例：

# Worker的Dockerfile示例
FROM openjdk:17-jdk-slim
COPY target/worker-app.jar /app.jar
# 用环境变量指定服务ID
ENV SERVICE_ID=ServiceA
ENTRYPOINT ["java", "-jar", "/app.jar", "--service.id=${SERVICE_ID}"]

启动容器时，只要传入不同的SERVICE_ID就行：

# 启动1个Service A实例
docker run -d -e SERVICE_ID=ServiceA worker-image:v1
# 启动2个Service C实例
docker run -d -e SERVICE_ID=ServiceC worker-image:v1
docker run -d -e SERVICE_ID=ServiceC worker-image:v1
# 启动5个高负载服务实例
for i in {1..5}; do docker run -d -e SERVICE_ID=HighLoadService worker-image:v1; done

3. Spring Worker的代码改造 #

在Spring应用里，启动时读取环境变量加载对应服务的逻辑，同时保证用单工作线程执行：

@SpringBootApplication
public class WorkerApplication {
    public static void main(String[] args) {
        SpringApplication app = new SpringApplication(WorkerApplication.class);
        // 从环境变量拿服务ID，传给Spring配置
        String serviceId = System.getenv("SERVICE_ID");
        app.setDefaultProperties(Collections.singletonMap("service.id", serviceId));
        app.run(args);
    }
}

// 服务执行组件，单线程处理请求
@Component
public class ServiceExecutor {
    private final String serviceId;
    private final Service targetService;
    // 用单线程池保证每次只跑一个任务
    private final ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();

    public ServiceExecutor(@Value("${service.id}") String serviceId, ServiceRepository serviceRepo) {
        this.serviceId = serviceId;
        // 从数据库加载对应服务的配置和执行逻辑
        this.targetService = serviceRepo.findByServiceId(serviceId);
    }

    @PostMapping("/execute")
    public ResponseEntity<String> triggerService(@RequestBody Map<String, Object> requestParams) {
        // 提交到单线程池执行
        singleThreadExecutor.submit(() -> targetService.run(requestParams));
        return ResponseEntity.ok("Service " + serviceId + " started");
    }
}

这里用Executors.newSingleThreadExecutor()严格保证单个工作线程执行服务，完全符合你的要求。

4. 网关的路由实现 #

用Spring Cloud Gateway做网关，配合服务发现（比如Eureka）来实现动态路由：

spring:
  cloud:
    gateway:
      routes:
        - id: service-execute-route
          uri: lb://worker-service
          predicates:
            - Path=/execute
          filters:
            # 从请求参数里提取serviceId，转发给Worker
            - RewritePath=/execute\?serviceId=(?<service>.*), /execute
            - AddRequestHeader=X-SERVICE-ID, {service}
  application:
    name: gateway-service

每个Worker实例注册到Eureka时，带上SERVICE_ID的元数据，网关会根据请求参数里的serviceId，自动把请求转发到对应服务的实例池（比如请求Service C就转发到那2个Worker实例）。

如果不想用Spring Cloud，也可以自己写个简单网关：用Redis维护服务ID -> 实例地址列表的映射，接收请求后轮选一个实例转发就行。

5. 数据库访问的注意事项 #

所有组件都连接同一个数据库，要注意两点：

• 给每个实例配置合理的数据库连接池大小，避免实例太多导致数据库连接耗尽
• 服务列表可以加Redis缓存，减少数据库的重复查询，服务配置更新时同步刷新缓存

6. 可选：自动化扩缩容 #

如果想更省心，可以用Docker Swarm或者Kubernetes来做自动扩缩容：

• 监控每个服务实例的CPU、内存或者请求队列长度
• 当达到阈值时自动启动更多对应服务的Docker实例，负载降下来后自动销毁多余实例

这样一套下来，既能保持对外只有一个REST端点，又能精准控制每个服务的实例数量，完美匹配你1×Service A、2×Service C、5×高负载服务的场景。

内容的提问来源于stack exchange，提问作者Mateusz Stefaniak