Maven多模块构建：复用同一Docker容器构建指定模块

Got it, let's tackle this problem step by step. The core idea is to spin up one Docker container once, reuse it for both module builds, and cut out that annoying container startup overhead you're dealing with. Here's how to make it work smoothly with the io.fabric8 docker-maven-plugin:

1. Choose a Base Build Image (Or Customize Your Own) #

First, you need a Docker image packed with all the tools your Maven builds require—JDK, Maven, and any extra dependencies your projects might need (like Git, Node.js, etc.).

• Use an official Maven image: For most projects, official Maven images (e.g., maven:3.8.6-openjdk-11) work perfectly. No need to build your own unless you have specific tooling needs.
• Customize if necessary: If your builds need extra tools, create a simple Dockerfile in your project root:

  FROM maven:3.8.6-openjdk-11
  # Add tools your projects depend on
  RUN apt-get update && apt-get install -y git nodejs npm
  

2. Configure the docker-maven-plugin in Your Parent POM #

Update your parent pom.xml to set up the plugin for container reuse, mount your local Maven repo (to avoid re-downloading dependencies), and run the build command for both modules.

Here's a complete configuration example:

<plugin>
  <groupId>io.fabric8</groupId>
  <artifactId>docker-maven-plugin</artifactId>
  <version>0.40.2</version> <!-- Use the latest stable version -->
  <configuration>
    <images>
      <!-- Swap this with your custom image name if you built one -->
      <image>
        <name>maven:3.8.6-openjdk-11</name>
        <alias>maven-build-container</alias>
      </image>
    </images>
    <run>
      <containerName>maven-reusable-build</containerName>
      <reuse>true</reuse> <!-- Critical: Lets the plugin reuse the existing container -->
      <volumes>
        <!-- Share your local Maven repo to skip repeated dependency downloads -->
        <volume>${user.home}/.m2:/root/.m2</volume>
        <!-- Mount your entire project root into the container -->
        <volume>${project.basedir}:/usr/src/app</volume>
      </volumes>
      <workingDir>/usr/src/app</workingDir>
      <!-- Maven command to build moduleB and moduleC (plus their dependencies) -->
      <cmd>mvn clean install -pl moduleB,moduleC -am</cmd>
    </run>
  </configuration>
</plugin>

Key Configuration Notes: #

• <reuse>true</reuse>: Tells the plugin to keep the container alive after the first build, so it can be reused for subsequent runs.
• Volume mounts:
  • ${user.home}/.m2:/root/.m2: Shares your local Maven cache with the container, eliminating redundant dependency downloads.
  • ${project.basedir}:/usr/src/app: Makes your entire project code accessible inside the container, so the Maven command can target moduleB and moduleC.
• <cmd>: The Maven command specifies exactly which modules to build (-pl moduleB,moduleC) and ensures their dependent modules are built too (-am).

3. Run the Build #

• First execution: Run mvn docker:run in your project root. This will pull the base image (if not already local), start the container, and execute the build.
• Subsequent runs: Just run mvn docker:run again. The plugin will detect the existing container, skip the slow startup process, and run the build command immediately.

4. Reset the Container (If Needed) #

If you ever need to start fresh (e.g., update the base image, clear cached dependencies), stop and delete the container with:

mvn docker:stop docker:rm

The next mvn docker:run will create a new container from scratch.

内容的提问来源于stack exchange，提问作者Maxim Popov