Ant转Maven：如何从外部脚本调用Pom.xml实现编译、运行及EAR生成？

Hey there! Let's walk through how to handle your J2EE project migration from Ant to Maven, focusing on executing Maven tasks externally and scripting those workflows. Maven's standardized lifecycle will make your builds more consistent, so let's dive in.

1. Executing Maven Tasks Externally (Command Line) #

First, make sure you have Maven installed (set up M2_HOME and added $M2_HOME/bin to your system PATH—this lets you run mvn commands from any terminal window).

Here’s how to run the key tasks you mentioned directly from outside your codebase:

Compile the Project #

To compile your main Java source code and output class files to target/classes:

mvn compile

If you need to compile test sources too, use mvn test-compile instead.

Run the J2EE Project #

Maven doesn’t have a built-in "run" command for J2EE, but you can use plugins to deploy and run your app directly. For example:

• For web modules (WARs), use the Jetty plugin:

  mvn jetty:run
  

• Or the Tomcat plugin:

  mvn tomcat7:run
  

Note: You’ll need to add these plugins to your pom.xml first. For example, the Jetty plugin configuration would look like this in your pom:

<build>
  <plugins>
    <plugin>
      <groupId>org.eclipse.jetty</groupId>
      <artifactId>jetty-maven-plugin</artifactId>
      <version>9.4.50.v20221201</version>
      <configuration>
        <httpConnector>
          <port>8080</port>
        </httpConnector>
      </configuration>
    </plugin>
  </plugins>
</build>

Generate the EAR File #

To build and package your project as an EAR, you need two key steps:

1. Set the packaging in your pom.xml to ear:

   <packaging>ear</packaging>
   

2. Add the Maven EAR plugin to handle EAR assembly (this can generate application.xml automatically if you configure it):

   <build>
     <plugins>
       <plugin>
         <groupId>org.apache.maven.plugins</groupId>
         <artifactId>maven-ear-plugin</artifactId>
         <version>3.3.0</version>
         <configuration>
           <!-- Configure modules (WARs, JARs) to include in the EAR -->
           <modules>
             <webModule>
               <groupId>com.yourcompany</groupId>
               <artifactId>your-web-module</artifactId>
               <contextRoot>/your-app</contextRoot>
             </webModule>
           </modules>
         </configuration>
       </plugin>
     </plugins>
   </build>
   

Then run this command to generate the EAR (it will end up in the target directory):

mvn package

If you want to install the EAR to your local Maven repository for reuse, use mvn install instead.

2. Calling Maven via External Scripts or Code #

Absolutely! You can automate these Maven commands using shell scripts, batch files, or even custom code. Here are a few examples:

Shell Script (Linux/macOS) #

Create a build-and-deploy.sh file in your project root (or anywhere you want, just update the project path):

#!/bin/bash

# Define your project root path (where pom.xml lives)
PROJECT_DIR="/path/to/your/j2ee-project"

# Navigate to project directory and run tasks
cd $PROJECT_DIR

echo "Compiling project..."
mvn compile -DskipTests

echo "Running project on Jetty..."
mvn jetty:run & # Run in background if needed

echo "Generating EAR file..."
mvn package -DskipTests

Make it executable with chmod +x build-and-deploy.sh, then run it with ./build-and-deploy.sh.

Batch Script (Windows) #

Create a build-and-deploy.bat file:

@echo off

set PROJECT_DIR=C:\path\to\your\j2ee-project

cd %PROJECT_DIR%

echo Compiling project...
mvn compile -DskipTests

echo Running project on Jetty...
mvn jetty:run

echo Generating EAR file...
mvn package -DskipTests

Double-click the file or run it from Command Prompt.

Java Code (Custom Scripting) #

If you need to call Maven from a Java program, use ProcessBuilder to execute the mvn command:

import java.io.IOException;

public class MavenExecutor {
    public static void main(String[] args) throws IOException {
        // Path to your project's pom.xml directory
        String projectPath = "/path/to/your/j2ee-project";
        
        // Execute Maven package command
        ProcessBuilder processBuilder = new ProcessBuilder("mvn", "package", "-DskipTests");
        processBuilder.directory(new java.io.File(projectPath));
        
        // Start the process and capture output (optional)
        Process process = processBuilder.start();
        
        // You can read the process input/output streams to check success/failure
        java.io.InputStream inputStream = process.getInputStream();
        java.io.BufferedReader reader = new java.io.BufferedReader(new java.io.InputStreamReader(inputStream));
        String line;
        while ((line = reader.readLine()) != null) {
            System.out.println(line);
        }
    }
}

Quick Migration Tips #

• Dependency Conversion: Move your Ant-managed dependencies to Maven’s <dependencies> section in pom.xml. Use mvn dependency:tree to verify dependencies and catch conflicts.
• Lifecycle Consistency: Maven follows a standard build lifecycle (clean → compile → test → package → install → deploy), so you don’t need to define custom targets like in Ant.
• Skip Tests: Add -DskipTests to commands if you want to skip test execution during builds (useful for quick iterations).

内容的提问来源于stack exchange，提问作者Kiran Chand