Precompila JSP con Gradle

Question

im cercando di cambiare il nostro processo di costruzione da Maven a Gradle (V 2.9). In Maven stavo usando precompilazione per JSP è come questo:

 <plugin> 
      <groupId>org.eclipse.jetty</groupId> 
      <artifactId>jetty-jspc-maven-plugin</artifactId> 
      <version>9.2.7.v20150116</version> 
      <executions> 
       <execution> 
        <phase>package</phase> 
        <id>jspc</id> 
        <goals> 
         <goal>jspc</goal> 
        </goals> 
        <configuration> 
         <excludes>**\/*inc_page_bottom.jsp,**\/*inc_page_top.jsp</excludes> 
         <includes>**\/*.jsp</includes> 
        </configuration> 
       </execution> 
      </executions> 
     </plugin> 

e stava funzionando benissimo. Ora sto cercando di trovare un modo per fare lo stesso con gradle. Ho trovato alcuni esempi di informazioni/build.gradle ma niente funzionava davvero. Im utilizza attualmente Tomcat 7 come servlet container e sto pianificando di passare tra alcune settimane a 8. Sarebbe perfetto naturalmente compilarli per il container servlet di destinazione ma, prima di tutto, sarei felice di precompilarli del tutto come se stessi facendo questo con Maven per/con pontile.

Una parte del mio build.gradle attuale, che mi dà un errore:

buildscript { 
    repositories { 
     jcenter() 
    } 

    dependencies { 
     classpath 'com.bmuschko:gradle-tomcat-plugin:2.2.4' 
    } 
} 

apply plugin: 'com.bmuschko.tomcat' 

tomcat { 
    jasper { 
     validateXml = true 
     errorOnUseBeanInvalidClassAttribute = false 
     compilerSourceVM = "1.8" 
     compilerTargetVM = "1.8" 
    } 
} 

task compileJsps(type: JavaCompile, dependsOn: 'clean') { 
    dependsOn tomcatJasper 
    group = 'build' 
    description = 'Translates and compiles JSPs' 
    classpath = configurations.tomcat + sourceSets.main.output + sourceSets.main.runtimeClasspath 
    sourceCompatibility = "1.8" 
    targetCompatibility = "1.8" 
    destinationDir = file("$buildDir/jasper-classes") 
    sourceSets { 
     main { 
      java { 
       srcDir "$buildDir/jasper" 
      } 
     } 
    } 
} 

dependencies { 
    def tomcatVersion = '7.0.59' 
    tomcat "org.apache.tomcat.embed:tomcat-embed-core:${tomcatVersion}", 
     "org.apache.tomcat.embed:tomcat-embed-logging-juli:${tomcatVersion}", 
     "org.apache.tomcat.embed:tomcat-embed-jasper:${tomcatVersion}" 
} 

Im ottenendo il seguente errore:

:tomcatJasper FAILED 
FAILURE: Build failed with an exception. 
* What went wrong: 
Execution failed for task ':tomcatJasper'. 
> org.apache.jasper.JasperException: file:/xxx/xxx/xxx/xxx/src/main/webapp/index.jsp (line: 6, column: 0) The value for the useBean class attribute xxx.xxx.xxx.XxxXxx is invalid. 

Eseguendo questo jsp in Tomcat 7 funziona bene ... Qualcuno ha un howto aggiornato o un suggerimento?

Answer 1

Con gradle, è possibile chiamare direttamente il compilatore JSPC. In questo modo è esplicito su cosa sta succedendo. Usiamo qualcosa come il seguente.

Un paio di cose da notare.

1. Il compilatore JSPC ha una dipendenza Ant, in modo che deve essere aggiunto al classpath
2. Il compilatore JSPC utilizza log4j, così creiamo un file di proprietà per l'uscita un po 'la registrazione di base
3. Il compilatore JSPC è incorporato all'interno di Jetty, che è una dipendenza "fornitaCompile", quindi sul nostro classpath di runtime.

In ogni caso, il nostro gradle è simile a;

configurations { 
    jspc 
} 

dependencies { 
    jspc 'org.apache.ant:ant:1.10.1' 
} 

def jspSrc = "$projectDir/src/main/webapp" 
def jspJavaSrc = "$buildDir/jsp-java-source" 
def jspPackage = "com.example.jsp" 

task writeJspcProperties(type: WriteProperties) { 
    outputFile = "$buildDir/log4j.jspc.properties" 
    property('log4j.rootLogger', 'WARN, stdout') 
    property('log4j.logger.org.apache', 'INFO, stdout') 
    property('log4j.appender.stdout', 'org.apache.log4j.ConsoleAppender') 
    property('log4j.appender.stdout.Target', 'System.out') 
    property('log4j.appender.stdout.layout', 'org.apache.log4j.PatternLayout') 
    property('log4j.appender.stdout.layout.ConversionPattern', '%d [%C] %m%n') 
} 

task jspToJava(type: JavaExec, dependsOn: [compileJava, writeJspcProperties]) { 

    inputs.dir jspSrc 
    outputs.dir jspJavaSrc 

    File xmlPartial = file("$jspJavaSrc/WEB-INF/web.xml.partial") 

    doFirst { 
     // Create the target WEB-INF folder so the JspC can create the web.xml.partial 
     File webInfFolder = xmlPartial.getParentFile() 
     if (!webInfFolder.exists()) { 
      webInfFolder.mkdirs() 
     } 
    } 

    classpath = configurations.jspc + sourceSets.main.runtimeClasspath 
    main = 'org.apache.jasper.JspC' 
    jvmArgs "-Dlog4j.configuration=file:$buildDir/log4j.jspc.properties" 

    args '-webapp', jspSrc, 
      '-d', jspJavaSrc, 
      '-p', jspPackage, 
      '-webxmlencoding', 'UTF-8', 
      '-webinc', xmlPartial.absolutePath 

    doLast { 
     // Merge the partial XML with the original 
     String originalXML = file("$jspSrc/WEB-INF/web.xml").text 
     String xmlToMerge = xmlPartial.text 
     String mergedXML = originalXML.replaceFirst('(?s)(<web-app.*?>)', '$1' + xmlToMerge) 
     file("$jspJavaSrc/WEB-INF/web.xml").text = mergedXML 
    } 
} 

[Modifica; notevolmente semplificato la compilazione JSP]

Answer 2

Nella tua build.gradle principale in fondo fare

apply from: 'jspc.gradle' 

Poi il file jspc.gradle assomiglia:

buildscript { 
    repositories { 
     jcenter() 
    } 


    dependencies { 
     classpath 'com.bmuschko:gradle-tomcat-plugin:2.2.5' 
    } 
} 

apply plugin: com.bmuschko.gradle.tomcat.TomcatPlugin 
apply plugin: 'java' 

dependencies { 
    def tomcatVersion = '8.0.42' 
    tomcat "org.apache.tomcat.embed:tomcat-embed-core:${tomcatVersion}", 
      "org.apache.tomcat.embed:tomcat-embed-logging-juli:${tomcatVersion}", 
      "org.apache.tomcat.embed:tomcat-embed-jasper:${tomcatVersion}", 
      "javax.servlet:jstl:1.2" 

    providedCompile "javax.servlet:servlet-api:2.5" 

} 

quindi di utilizzare la precompilazione fare:

gradle tomcatJasper