如何在Java/Gradle多模块项目中结合Makefile编译or-tools依赖模块？

Got it, let’s walk through how to integrate your or-tools Makefile build into your Gradle project so you can run everything with standard Gradle commands like ./gradlew build or ./gradlew run. Here’s a practical, step-by-step approach:

First, you’ll define tasks in your orModule/build.gradle to run the make commands that compile and clean or-tools. These will be Exec tasks since they’re running shell commands.

Add this to your build script:

// Task to compile or-tools using its Makefile
task compileOrTools(type: Exec) {
    // Point this to the directory where your or-tools source + Makefile lives
    workingDir "${projectDir}/or-tools-source"
    
    // Run the default make target (adjust to 'all' or specific targets if needed)
    commandLine 'make'

    // Optional: Print make output to the console for debugging
    standardOutput = System.out
    errorOutput = System.err
}

// Task to clean or-tools build artifacts
task cleanOrTools(type: Exec) {
    workingDir "${projectDir}/or-tools-source"
    commandLine 'make', 'clean'
}

Adjust the workingDir path to match where your or-tools source and Makefile are located in the orModule module. If you need to run a specific make target (like make java instead of the default), update the commandLine arguments accordingly.

You want Gradle to automatically compile or-tools before building your Java code, and clean or-tools artifacts when you run ./gradlew clean. Add these lines to wire the tasks into the lifecycle:

// Compile or-tools before compiling the module's Java code
compileJava.dependsOn compileOrTools

// Clean or-tools artifacts when running the main clean task
clean.dependsOn cleanOrTools

Now, whenever you run ./gradlew build, Gradle will first run make in your or-tools directory, then compile your Java code. Running ./gradlew clean will clean both your Gradle build outputs and the or-tools build artifacts.

Once or-tools is compiled, you need to tell Gradle to use its output (usually a JAR file, plus native libraries if applicable) as a dependency for orModule. Add this to your dependencies block:

dependencies {
    // Replace with the actual path to the compiled or-tools JAR
    implementation files("${projectDir}/or-tools-source/build/libs/or-tools.jar")
    
    // If or-tools generates native libraries (.so, .dll, .dylib), add them for runtime
    runtimeOnly fileTree(dir: "${projectDir}/or-tools-source/build/lib", include: ['*.so', '*.dll', '*.dylib'])
}

Double-check the paths here—they need to match where your Makefile outputs the compiled artifacts. If you’re unsure, run make manually once and note where the JAR/libraries end up.

To avoid build failures if the Makefile is missing or the environment isn’t set up right, add a pre-check to the compileOrTools task:

compileOrTools.doFirst {
    def makefile = file("${workingDir}/Makefile")
    if (!makefile.exists()) {
        throw new GradleException("Makefile not found at ${makefile.absolutePath}—check your workingDir path!")
    }
    
    // Optional: Verify that 'make' is available on the system
    def makeExists = project.exec {
        commandLine 'which', 'make'
        ignoreExitValue true
    }.exitValue == 0
    
    if (!makeExists) {
        throw new GradleException("'make' command not found—install it first (e.g., via apt, brew, or MinGW)")
    }
}

This will catch common issues early and give clear error messages instead of vague build failures.

• If you need to pass environment variables to the make command (like JAVA_HOME or CXX), add an environment block to the compileOrTools task:

  compileOrTools.environment([
      'JAVA_HOME': System.getenv('JAVA_HOME'),
      'CXX': 'g++'
  ])
  

• For Windows users: You’ll need a make executable (e.g., from MinGW or Cygwin). Update the commandLine to use the full path to make.exe if it’s not in your system PATH.

Now you can run ./gradlew run or ./gradlew build like a normal Gradle project, and the or-tools compilation will happen automatically in the background.

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