DEV Community: Query Filter

docker120

Query Filter — Fri, 08 May 2026 20:55:01 +0000

// 1. Define your paths (Ensure forward slashes for Windows compatibility)
def java8Path = "C:/Program Files/Java/jdk1.8.0_321" 
def java21Path = "C:/Program Files/JetBrains/IntelliJ IDEA 2024.3.3 Community Edition/jbr"
def combinedPaths = "${java8Path},${java21Path}"

// 2. Inject directly into System Properties for the JVM
System.setProperty("org.gradle.java.installations.paths", combinedPaths)

// 3. Inject into Gradle's project properties without using the 'settings' keyword
project.ext["org.gradle.java.installations.paths"] = combinedPaths

docker119

Query Filter — Fri, 08 May 2026 20:45:49 +0000

// Force the path injection into the JVM System Properties immediately
def java8Path = "C:/Program Files/Java/jdk1.8.0_321" 
def java21Path = "C:/Program Files/JetBrains/IntelliJ IDEA 2024.3.3 Community Edition/jbr"

System.setProperty("org.gradle.java.installations.paths", "${java8Path},${java21Path}")

// Optional: Also set it as a Gradle property for redundancy
settings.extensions.extraProperties.set("org.gradle.java.installations.paths", "${java8Path},${java21Path}")

docker118

Query Filter — Fri, 08 May 2026 20:36:44 +0000

// Explicitly wire the compiler to the task
tasks.withType(JavaCompile).configureEach {
    def targetVersion = project.hasProperty('useJava8') ? 8 : 21

    // This forces the task to look up the compiler from the toolchains Gradle found
    javaCompiler = javaToolchains.compilerFor {
        languageVersion = JavaLanguageVersion.of(targetVersion)
    }

    println "Task ${name} is using compiler version: ${targetVersion}"
}

docker117

Query Filter — Fri, 08 May 2026 19:59:36 +0000

java {
    toolchain {
        // Use your existing logic to decide the version
        def target = project.hasProperty('useJava8') ? 8 : 21
        languageVersion = JavaLanguageVersion.of(target)
    }
}

// Dynamically inject installation paths from the environment
def envJava8 = System.getenv("JAVA_HOME_8")
def envJava21 = System.getenv("JAVA_HOME_21")

if (envJava8 || envJava21) {
    def paths = [envJava8, envJava21].findAll { it != null }.join(",")
    project.extensions.extraProperties.set("org.gradle.java.installations.paths", paths)
}

docker116

Query Filter — Fri, 08 May 2026 19:53:21 +0000

tasks.register('verifyEnvironment') {
    doLast {
        println "--- Environment Verification ---"
        println "JAVA_HOME_8 (Env):  ${System.getenv('JAVA_HOME_8')}"
        println "JAVA_HOME_21 (Env): ${System.getenv('JAVA_HOME_21')}"
        println "--- Gradle View ---"
        println "Current Toolchain:  ${java.toolchain.languageVersion.get()}"

        if (System.getenv('JAVA_HOME_8') == null) {
            println "WARNING: Gradle cannot see JAVA_HOME_8. Check your Environment Variables."
        }
    }
}

docker115

Query Filter — Fri, 08 May 2026 16:28:10 +0000

dependencies {
    // We only need the API for compilation, so we can use 'compileOnly' 
    // and exclude the runtime that pulls in missing glassfish/jaxb artifacts
    implementation('javax.xml.ws:jaxws-api:2.3.1') {
        exclude group: 'com.sun.xml.ws', module: 'jaxws-rt'
        exclude group: 'org.glassfish.jaxb', module: 'jaxb-runtime'
    }

    implementation 'javax.annotation:javax.annotation-api:1.3.2'
}

docker114

Query Filter — Fri, 08 May 2026 16:21:58 +0000

dependencies {
    // These add the missing 'javax.xml.ws' packages back for Java 21 compilation
    implementation 'javax.xml.ws:jaxws-api:2.3.1'
    implementation 'javax.annotation:javax.annotation-api:1.3.2'

    // If you use SOAP/XML extensively, you may also need these:
    implementation 'javax.xml.bind:jaxb-api:2.3.1'
    implementation 'com.sun.xml.ws:jaxws-rt:2.3.1'
}

docker112

Query Filter — Fri, 08 May 2026 14:45:30 +0000

// Define the path to your IntelliJ JDK
def intellijJbrPath = "C:/Program Files/JetBrains/IntelliJ IDEA/jbr"

// Hardcode the default to 'true' if not provided via command line
if (!project.hasProperty('useJava21')) {
    project.ext.useJava21 = "true" 
}

java {
    toolchain {
        // Now it defaults to 21 unless you explicitly pass -PuseJava21=false
        if (project.property('useJava21') == "true") {
            languageVersion = JavaLanguageVersion.of(21)
        } else {
            languageVersion = JavaLanguageVersion.of(8)
        }
    }
}

// Ensure the Toolchain knows where to look for Java 21
if (project.property('useJava21') == "true") {
    tasks.withType(JavaCompile).configureEach {
        javaCompiler = javaToolchains.compilerFor {
            languageVersion = JavaLanguageVersion.of(21)
        }
    }
    // This is the "internal" way to register that path without a properties file
    System.setProperty("org.gradle.java.installations.paths", intellijJbrPath)
}

docker111

Query Filter — Fri, 08 May 2026 14:12:31 +0000

import java.text.SimpleDateFormat

jar {
    archiveBaseName = project.ext.artifactId
    archiveVersion = project.ext.version

    // Create a timestamp string
    def buildDate = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ssZ").format(new Date())

    manifest {
        attributes(
            "Built-By": System.getProperty("user.name"),
            "Implementation-Version": archiveVersion,
            "Build-Date": buildDate, // New attribute
            "Build-Jdk": "${System.getProperty('java.version')} (${System.getProperty('java.vendor')})",
            "Build-OS": "${System.getProperty('os.name')} ${System.getProperty('os.arch')}",
            "Compile-Source-JDK": project.sourceCompatibility,
            "Compile-Target-JDK": project.targetCompatibility
        )
    }
}

docker110

Query Filter — Fri, 08 May 2026 14:01:50 +0000

jar {
    archiveBaseName = project.ext.artifactId
    archiveVersion = project.ext.version

    manifest {
        attributes(
            "Built-By": System.getProperty("user.name"),
            "Implementation-Version": archiveVersion,
            "Created-By": "Gradle ${gradle.gradleVersion}",
            "Build-Jdk": "${System.getProperty('java.version')} (${System.getProperty('java.vendor')} ${System.getProperty('java.vm.version')})",
            "Build-OS": "${System.getProperty('os.name')} ${System.getProperty('os.arch')} ${System.getProperty('os.version')}",
            "Compile-Source-JDK": project.sourceCompatibility,
            "Compile-Target-JDK": project.targetCompatibility
        )
    }
}

docker109

Query Filter — Thu, 07 May 2026 20:32:48 +0000

// --- Added logic to display the Manifest ---
        println "MANIFEST ENTRIES:"
        java.util.jar.JarFile jf = new java.util.jar.JarFile(jarFile)
        def manifestAttributes = jf.manifest.mainAttributes
        manifestAttributes.each { key, value ->
            println "  ${key}: ${value}"
        }
        jf.close() // Always close the file handle
        println "------------------------------------------------------------"
    }

docker108

Query Filter — Thu, 07 May 2026 20:29:52 +0000

version = '1.0_A20'

jar {
    archiveBaseName = 'etsf'
    archiveVersion = '1.0_A20'

    manifest {
        attributes(
            "Built-By": System.getProperty("user.name"),
            "Implementation-Version": archiveVersion
        )
    }

    // This block executes after the jar file is actually written to disk
    doLast {
        def jarFile = archiveFile.get().asFile
        def sizeInKB = String.format("%.2f", jarFile.length() / 1024)
        def timestamp = new java.text.SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date())

        println "------------------------------------------------------------"
        println "BUILD SUCCESSFUL: Artifact Generated"
        println "File:      ${jarFile.name}"
        println "Path:      ${jarFile.absolutePath}"
        println "Size:      ${sizeInKB} KB"
        println "Timestamp: ${timestamp}"
        println "------------------------------------------------------------"
    }
}