tutorial - gradle variable in string

Generación del metamodelo JPA2 a partir de un script de compilación de Gradle

Question

Estoy intentando configurar un script de compilación de Gradle para un nuevo proyecto. Ese proyecto utilizará JPA 2 junto con Querydsl .

En la siguiente página de la documentación de referencia de Querydsl , explican cómo configurar su JPAAnnotationProcessor (apt) para Maven y Ant.

Me gustaría hacer lo mismo con Gradle, pero no sé cómo y mi querido amigo no me ayudó mucho en esto. Necesito encontrar una manera de invocar Javac (preferiblemente sin dependencias adicionales) con argumentos para poder especificar el procesador que apt debería usar (?)

Answer 1

Aquí hay una configuración simple que funciona y se integra perfectamente con netbeans. Javac básicamente hará todo el trabajo necesario sin mucha intervención. El resto son pequeñas golosinas que harán que funcione con IDE como Netbeans.

apply plugin:''java''

dependencies {
    // Compile-time dependencies should contain annotation processors
    compile(group: ''com.mysema.querydsl'', name: ''querydsl-apt'', version: ''1.8.4'')
    compile(group: ''com.mysema.querydsl'', name: ''querydsl-jpa'', version: ''1.8.4'')
    compile(group: ''org.slf4j'', name: ''slf4j-log4j12'', version: ''1.6.1'')
}

ext {
    generatedSourcesDir = file("${buildDir}/generated-sources/javac/main/java")
}

// This section is the key to IDE integration.
// IDE will look for source files in both in both
//
//  * src/main/java
//  * build/generated-sources/javac/main/java
//
sourceSets {
    main {
        java {
            srcDir ''src/main/java''
            srcDir generatedSourcesDir
        }
    }
}

// These are the only modifications to build process that are required.
compileJava {
    doFirst {
        // Directory should exists before compilation started.
        generatedSourcesDir.mkdirs()
    }
    options.compilerArgs += [''-s'', generatedSourcesDir]
}

Y eso es. Javac hará el resto del trabajo.

Answer 2

Con Gradle 1.3 y más reciente (más antiguo no probado) puede usar Querydsl APT así:

configurations {
  javacApt
}
dependencies {
  javacApt ''com.mysema.querydsl:querydsl-apt:3.3.0''
}
compileJava {
  options.compilerArgs <<
    ''-processorpath'' << (configurations.compile + configurations.javacApt).asPath <<
    ''-processor'' << ''com.mysema.query.apt.jpa.JPAAnnotationProcessor''
}

Estos argumentos del compilador se pasan directamente a javac.

Para usar con el compilador maravilloso, reemplace compileJava con compileGroovy .

Answer 3

El ejemplo de Querydsl Ant debería funcionar más o menos como cuando eliminas todo el XML. Entonces termina siendo algo así:

javac -sourcepath ${src} -cp ${cp} -proc:only -processor com.mysema.query.apt.jpa.JPAAnnotationProcessor -s ${generated}

src , cp y generated probablemente podrá extraer de Gradle.

Answer 4

La esencia de este tipo funcionó para mí: https://gist.github.com/EdwardBeckett/5377401

sourceSets {
    generated {
        java {
            srcDirs = [''src/main/generated'']
        }
    }
}

configurations {
    querydslapt
}

dependencies {
    compile ''org.hibernate.javax.persistence:hibernate-jpa-2.0-api:1.0.1.Final''
    compile "com.mysema.querydsl:querydsl-jpa:$querydslVersion"
    querydslapt "com.mysema.querydsl:querydsl-apt:$querydslVersion"
}

task generateQueryDSL(type: JavaCompile, group: ''build'', description: ''Generates the QueryDSL query types'') {
    source = sourceSets.main.java
    classpath = configurations.compile + configurations.querydslapt
    options.compilerArgs = [
            "-proc:only",
            "-processor", "com.mysema.query.apt.jpa.JPAAnnotationProcessor"
    ]
    destinationDir = sourceSets.generated.java.srcDirs.iterator().next()
}

compileJava {
    dependsOn generateQueryDSL
    source generateQueryDSL.destinationDir
}

compileGeneratedJava {
    dependsOn generateQueryDSL
    options.warnings = false
    classpath += sourceSets.main.runtimeClasspath
}

clean {
    delete sourceSets.generated.java.srcDirs
}

idea {
    module {
        sourceDirs += file(''src/main/generated'')
    }
}

Answer 5

No lo probé pero esto debería funcionar:

repositories {
    mavenCentral()
}
apply plugin: ''java''
dependencies {
   compile(group: ''com.mysema.querydsl'', name: ''querydsl-apt'', version: ''1.8.4'')
   compile(group: ''com.mysema.querydsl'', name: ''querydsl-jpa'', version: ''1.8.4'')
   compile(group: ''org.slf4j'', name: ''slf4j-log4j12'', version: ''1.6.1'')
}

compileJava {
    doFirst {
        Map otherArgs = [
            includeAntRuntime: false,
            destdir: destinationDir,
            classpath: configurations.compile.asPath,
            sourcepath: '''',
            target: targetCompatibility,
            source: sourceCompatibility
        ]
        options.compilerArgs = [
            ''-processor'', ''com.mysema.query.apt.jpa.JPAAnnotationProcessor'',
            ''-s'', "${destinationDir.absolutePath}".toString()
        ]
        Map antOptions = otherArgs + options.optionMap()
        ant.javac(antOptions) {
            source.addToAntBuilder(ant, ''src'', FileCollection.AntType.MatchingTask)
            options.compilerArgs.each {value ->
                compilerarg(value: value)
            }
        }
    }
}

Espero eso ayude.

Answer 6

Para usar el generador de metamodelos JPA con Gradle, estoy usando con éxito lo siguiente en mi build.gradle y funciona como un encanto:

buildscript {
    ext {}
    repositories { // maven central & plugins.gradle.org/m2 }
    dependencies {
        // other dependencies, e.g. Spring
        classpath(''gradle.plugin.at.comm_unity.gradle.plugins:jpamodelgen-plugin:1.1.1'')
    }

    apply plugin: ''at.comm_unity.gradle.plugins.jpamodelgen''

    dependencies {
        compile(''org.hibernate:hibernate-jpamodelgen:5.1.0.Final'')
    }

    jpaModelgen {
        jpaModelgenSourcesDir = "src/main/java"
    }

    compileJava.options.compilerArgs += ["-proc:none"]
}

Dentro de la tarea de compilación, se generan las clases de metamodelo estático con el sufijo ''_''. Luego se ubican en el mismo directorio que los modelos de @Entity.

Answer 7

Si bien no tengo ningún problema con el uso que Gradle hace de Ant, estoy de acuerdo con el póster original de que no es deseable en este caso. Encontré un proyecto de github por Tom Anderson que describe lo que creo que es un mejor enfoque. Lo modifiqué un poco para que se ajustara a mis necesidades (salida a src / main / generada) para que se vea como:

sourceSets {
     generated
}

sourceSets.generated.java.srcDirs = [''src/main/generated'']

configurations {
     querydslapt
}

dependencies {     
    compile ''mine go here''
    querydslapt ''com.mysema.querydsl:querydsl-apt:2.7.1''
}

task generateQueryDSL(type: Compile, group: ''build'', description: ''Generates the QueryDSL query types'') {
         source = sourceSets.main.java
         classpath = configurations.compile + configurations.querydslapt
         options.compilerArgs = [
                "-proc:only",
                "-processor", "com.mysema.query.apt.jpa.JPAAnnotationProcessor"
         ]
         destinationDir = sourceSets.generated.java.srcDirs.iterator().next()
}
compileJava.dependsOn generateQueryDSL

Este enfoque tiene mucho más sentido para mí que el otro, si también lo hace para usted, entonces tiene otra opción para la generación de consultas.