Great questions! Let's break down how to solve both of these challenges with the exec-maven-plugin step by step.

1. Adding Try-Catch Style Error Handling for Executed Commands #

First off: the exec-maven-plugin doesn't have built-in try-catch logic in its core configuration. But don't worry—you can replicate this behavior by wrapping your target command in a shell or batch script, which lets you handle errors gracefully. Here's how to do it for different operating systems:

For Unix-like Systems (Linux/macOS) #

Create a shell script (e.g., run-cmake.sh) with error checking:

#!/bin/bash

# Execute the appropriate CMake command
if [ -n "${CMAKE_V_HOME}" ]; then
    "${CMAKE_V_HOME}/cmake" "$@"
else
    cmake "$@"
fi

# Catch errors and add custom handling
if [ $? -ne 0 ]; then
    echo "⚠️ CMake command failed! Check your configuration or inputs."
    # Add cleanup steps or fallback actions here if needed
    exit 1 # Ensure Maven picks up the failure code
fi

Then configure the plugin to run this script instead of calling CMake directly:

<plugin>
    <groupId>org.codehaus.mojo</groupId>
    <artifactId>exec-maven-plugin</artifactId>
    <version>3.1.0</version>
    <executions>
        <execution>
            <id>execute-cmake</id>
            <goals>
                <goal>exec</goal>
            </goals>
            <configuration>
                <executable>bash</executable>
                <arguments>
                    <argument>run-cmake.sh</argument>
                    <!-- Pass your CMake arguments here -->
                    <argument>-S</argument>
                    <argument>.</argument>
                    <argument>-B</argument>
                    <argument>build</argument>
                </arguments>
            </configuration>
        </execution>
    </executions>
</plugin>

For Windows Systems #

Create a batch script (e.g., run-cmake.bat) with error handling:

@echo off

:: Run the right CMake command based on environment variable
if defined CMAKE_V_HOME (
    "%CMAKE_V_HOME%\cmake.exe" %*
) else (
    cmake.exe %*
)

:: Check for errors and exit with code
if %errorlevel% neq 0 (
    echo ⚠️ CMake command failed! Verify your setup.
    exit /b %errorlevel%
)

Update the plugin configuration to use this batch script:

<plugin>
    <groupId>org.codehaus.mojo</groupId>
    <artifactId>exec-maven-plugin</artifactId>
    <version>3.1.0</version>
    <executions>
        <execution>
            <id>execute-cmake</id>
            <goals>
                <goal>exec</goal>
            </goals>
            <configuration>
                <executable>cmd.exe</executable>
                <arguments>
                    <argument>/c</argument>
                    <argument>run-cmake.bat</argument>
                    <argument>-S</argument>
                    <argument>.</argument>
                    <argument>-B</argument>
                    <argument>build</argument>
                </arguments>
            </configuration>
        </execution>
    </executions>
</plugin>

If you want to avoid external scripts, you could also use Maven profiles with conditional activation to handle failure scenarios, but scripts give you more control over custom error messages or cleanup steps.

2. Adapting to Different CMake Executable Paths (No Source Code Changes) #

To support both cmake and ${env.CMAKE_V_HOME}/cmake without modifying your pom.xml every time, you have two solid options:

Option 1: Maven Profiles with Environment-Based Activation #

Define two profiles that auto-activate based on whether the CMAKE_V_HOME environment variable exists. Maven will automatically pick the right configuration for your environment:

<profiles>
    <profile>
        <id>cmake-custom-path</id>
        <activation>
            <property>
                <name>env.CMAKE_V_HOME</name>
            </property>
        </activation>
        <properties>
            <cmake.executable>${env.CMAKE_V_HOME}/cmake</cmake.executable>
        </properties>
    </profile>
    <profile>
        <id>cmake-default</id>
        <activation>
            <activeByDefault>true</activeByDefault>
        </activation>
        <properties>
            <cmake.executable>cmake</cmake.executable>
        </properties>
    </profile>
</profiles>

<build>
    <plugins>
        <plugin>
            <groupId>org.codehaus.mojo</groupId>
            <artifactId>exec-maven-plugin</artifactId>
            <version>3.1.0</version>
            <executions>
                <execution>
                    <id>execute-cmake</id>
                    <goals>
                        <goal>exec</goal>
                    </goals>
                    <configuration>
                        <executable>${cmake.executable}</executable>
                        <!-- Add your CMake arguments here -->
                        <arguments>
                            <argument>-S</argument>
                            <argument>.</argument>
                            <argument>-B</argument>
                            <argument>build</argument>
                        </arguments>
                    </configuration>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

Option 2: Concise Property Interpolation (No Profiles) #

If you prefer a more compact setup, use Maven's built-in property interpolation with a fallback. This works in most modern Maven versions:

<build>
    <plugins>
        <plugin>
            <groupId>org.codehaus.mojo</groupId>
            <artifactId>exec-maven-plugin</artifactId>
            <version>3.1.0</version>
            <executions>
                <execution>
                    <id>execute-cmake</id>
                    <goals>
                        <goal>exec</goal>
                    </goals>
                    <configuration>
                        <!-- Use custom path if CMAKE_V_HOME exists, else default cmake -->
                        <executable>${env.CMAKE_V_HOME:+${env.CMAKE_V_HOME}/cmake}${env.CMAKE_V_HOME:cmake}</executable>
                        <!-- Add your CMake arguments here -->
                        <arguments>
                            <argument>-S</argument>
                            <argument>.</argument>
                            <argument>-B</argument>
                            <argument>build</argument>
                        </arguments>
                    </configuration>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

The syntax ${env.CMAKE_V_HOME:+...} means: "If CMAKE_V_HOME is set, use the value after the +; otherwise, use the value after the :".

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