JCON 2017, Düsseldorf: Vortrag von Sonja Wittke (Senior Softwareingenieurin bei QAware). Abstract: In vielen Projekten ist Maven als Buildtool gesetzt. Entwicklungsteam und Kunde sind daran gewöhnt, die Buildinfrastruktur ist aufgesetzt, alles läuft stabil. Es gibt keinen offensichtlichen Grund, etwas daran zu ändern. Trotzdem haben wir den Build für eines unserer Kunden-Projekte auf Gradle umgestellt, planen die Umstellung weiterer Builds, und setzen für neue Projekte ausschließlich Gradle ein. In diesem Vortrag beschreiben wir, warum wir uns für den Einsatz von Gradle stark gemacht haben, und zeigen dabei die wesentlichen Vorteile und Features. Aus unserer täglichen Arbeit liefern wir faire Vergleichszahlen zwischen Maven und Gradle. Wir zeigen außerdem, was wir bei der Migration richtig, aber auch was wir falsch gemacht haben, und wie wir die Migration unserer weiteren Projekte angehen wollen.

1. SonjaWittke
sonja.wittke@qaware.de
Von Maven zu Gradle
in 45 Minuten
Düsseldorf, 24. Oktober 2017

2. Warum Gradle?

3. Ist Gradle wirklich
so viel schneller?
Mal wieder etwas
Neues ausprobieren
wäre nett.
Wäre eine gute
Einstiegsaufgabe…

4. Jetzt müssen wir nur noch
unseren Kunden überzeugen…
Foto: George Marks

5. Gradle als Buildtool – Einordnung und Features
5
Eigene groovy-basierte DSL, einfach erweiterbar
Polyglott mit einheitlichen Cross-Platform-Builds (Java, Groovy, Scala, Clojure,
Android, C++, ObjectiveC, JavaScript, CSS, Grunt, …)
Sprachbasiert
Problemlose IDE-Integration (Intellij, Eclipse, NetBeans, Android Studio, …)
Maven Repositories können problemlos angebunden werden
Problemlose Integration in bestehende Build-Infrastruktur
Einfach integrierbar
Schnelle inkrementelle BuildsPerformant

6. Gradle ist etabliert und hat im Thoughtworks Techradar
schon seit Mai 2013 den Status ADOPT.
6
https://www.thoughtworks.com/radar/tools/gradle
https://www.thoughtworks.com/radar/tools/maven

7. Gradle ermöglicht prägnante
& kurze Build-Konfigurationen.
7

8. Gradle ermöglicht performante inkrementelle Builds.
Das belegen Benchmarks und unsere Experimente.
8
https://gradle.org/gradle-vs-maven-performance/
Task Maven Gradle
Build mvn clean install
5:25 min
gradlew
clean build
3:45 min
Build nach 1 Änderung
(inkrementell)
mvn install
4:21 min
gradlew
build
0:39 min
Build ohne Tests 1:14 min 0:41 min
Build nach 1 Änderung
ohne Tests
0:41 min 0:10 min

9. Gradle war
gekauft. Und
wir auf
einmal ein
Pilotprojekt.
Foto: avid_creative – gettyimages.de

10. Und wie
bauen wir
das jetzt?
Foto: Zero Creatives – gettyimages.de

11. Unser Masterplan:
11
Foto: Mike Powell
Code kompiliert & Tests laufen1
Dependencies sind überführt2
Alle Plugins sind migriert3
Spezialaufgaben4

12. <name>esb</name>
<description>ESB application</description>
<modules>
<module>esb-modules</module>
<module>esb-adapter</module>
<module>esb-runtime</module>
</modules>
Wir setzen zuerst die Projektstruktur auf.
12
rootProject.name = 'esb'
include 'esb-modules'
include 'esb-adapter'
include 'esb-adapter:esb-vehicle-adapter'
include 'esb-adapter:esb-finance-adapter‘
include 'esb-runtime'
include 'esb-runtime:esb-bdr-runtime'
include 'esb-runtime:esb-bdr-runtime-it-tests'
<artifactId>esb-adapter</artifactId>
<version>1.5.0-SNAPSHOT</version>
<packaging>pom</packaging>
<parent>
<artifactId>esb</artifactId>
<groupId>de.qaware.esb</groupId>
<version>1.5.0-SNAPSHOT</version>
</parent>
<modules>
<module>esb-vehicle-adapter</module>
<module>esb-finance-adapter</module>
</modules>
In der pom eines
Moduls:
Definition von
Untermodulen
Gradle:
Gesamte Projektstruktur
in einer Settings-Datei
Maven:
Modul-Definition in
der root pom

13. <dependencies>
<dependency>
<groupId>commons-io</groupId>
<artifactId>commons-io</artifactId>
</dependency>
<dependency>
<groupId>commons-lang</groupId>
<artifactId>commons-lang</artifactId>
</dependency>
<dependency>
<groupId>de.qaware.tools</groupId>
<artifactId>tools-test</artifactId>
<scope>test</scope>
<exclusions>
<exclusion>
<artifactId>logback-classic</artifactId>
<groupId>ch.qos.logback</groupId>
</exclusion>
</exclusions>
</dependency>
</dependencies>
Dann schauen wir uns die Dependencies an.
13
dependencies {
compile group: 'commons-io', name: 'commons-io‘,
version: "$depVersions.commonsIo"
compile group: 'commons-lang', name: 'commons-lang‘,
version: "$depVersions.commonsLang"
testCompile libraries.tools_test
}
In Maven kennen
wir Scopes
Die Scopes entsprechen ungefähr
den Konfigurationen in Gradle.
Bei Bedarf definieren wir uns
eigene, z.B. für provided =
compileOnly + testRuntime
Exclusions geben
wir direkt an
Versionen legen wir
im Dependency
Management fest
Versionen definieren
wir z.B. in einer
zentralen HashMap.
Das geht auch
einfacher mit Plugins
von Netflix Nebula
oder Spring
Und in
Gradle?

14. Was ist eigentlich mit transitiven Dependencies?

15. Maven and Gradle walk into a bar (by Rafael Cordones):
Maven: I’d like a coffee, please.
Gradle: I’d like a coffee too, please.
Bartender: Here’s your coffee, Maven.
Bartender: And here’s your coffee with a croissant, Gradle.
Maven: Why don’t I get a croissant too?!
Bartender: For you Maven? Just the nearest explicitly stated
dependency.

16. Demo Time!

17. Und wie lösen wir jetzt Konflikte auf?
17
configurations.all {
exclude group: "org.springframework", module: "spring-asm"
resolutionStrategy {
force "org.apache.logging.log4j:log4j-slf4j-impl:$depVersions.log4j"
force "org.apache.logging.log4j:log4j-api:$depVersions.log4j"
force "org.apache.logging.log4j:log4j-core:$depVersions.log4j"
force "org.apache.logging.log4j:log4j-1.2-api:$depVersions.log4j"
force "org.apache.logging.log4j:log4j-jcl:$depVersions.log4j"
force "org.apache.logging.log4j:log4j-jul:$depVersions.log4j"
. . .
force "org.slf4j:slf4j-api:$depVersions.slf4j"
}
}
Wir können
globale
Exclusions
definieren
Oder über den
Resolution Manager
bestimmte Versionen
forcieren

18. Sind wir schon da?
18
Foto: Mike Powell
Code kompiliert & Tests laufen
Dependencies sind überführt
Alle Plugins sind migriert3
Spezialaufgaben4

19. Was machen wir jetzt mit den Plugins?
19
switch(mavenPlugin) {
case IN_GRADLE_API_INTEGRIERT:
return ALLES_GUT;
case OFFIZIELLES_GRADLE_PLUGIN_EXISTIERT:
return ALLES_GUT;
case INOFFIZIELLES_GRADLE_PLUGIN_EXISTIERT:
return MAESSIG_GUT;
case ANT_TASK_EXISTIERT:
return MAESSIG_GUT;
default:
// Es gibt noch gar nichts. Oder ich finde es einfach nicht...
return DUMM_GELAUFEN;
}

20. <plugin>
<artifactId>maven-failsafe-plugin</artifactId>
<configuration>
<includes>
<include>**/*FunctionalTest.java</include>
<include>**/*IntegrationTest.java</include>
</includes>
</configuration>
<executions>
<execution>
<goals>
<goal>integration-test</goal>
<goal>verify</goal>
</goals>
</execution>
</executions>
</plugin>
case IN_GRADLE_API_INTEGRIERT:
20
task integrationTest(type: Test) {
description = 'Run the integration tests'
group = 'verification'
include '**/*IntegrationTest.class'
include '**/*FunctionalTest.class'
reports.html.destination =
file("$reports.html.destination/integration")
reports.junitXml.destination =
file("$reports.junitXml.destination/integration")
}

21. <plugins>
<plugin>
<groupId>org.jacoco</groupId>
<artifactId>jacoco-maven-plugin</artifactId>
<version>0.7.9</version>
<executions>
{Ein paar Unit-Test spezifische Konfigurationen ...}
<execution>
<id>pre-integration-test</id>
<phase>pre-integration-test</phase>
<goals>
<goal>prepare-agent</goal>
</goals>
<configuration>
<destFile>${project.build.directory}/jacoco-it.exec</destFile>
</configuration>
</execution>
{Noch mehr Konfigurationen, um die Coverage-Reports für Integrationstests zu generieren ...}
</executions>
</plugin>
</plugins>
case OFFIZIELLES_GRADLE_PLUGIN_EXISTIERT:
21
Setup des
Jacoco-Agents
Konfiguration zur
Generierung von
Reports

22. subprojects {
apply plugin: 'jacoco'
task jacocoIntegrationTestReport(type: JacocoReport) {
group = 'verification'
dependsOn integrationTest
executionData integrationTest
sourceDirectories = files(sourceSets.main.java.srcDirs)
classDirectories = files(sourceSets.main.output.classesDir)
reports.html.destination = file("$buildDir/reports/jacoco/integration")
}
check.dependsOn(jacocoTestReport)
check.dependsOn(jacocoIntegrationTestReport)
}
case OFFIZIELLES_GRADLE_PLUGIN_EXISTIERT:
22
Die Generierung der
Reports lässt sich in
Gradle sehr einfach
konfigurieren.
Inoffizielle Plugins lassen
sich genauso einbinden.
Man muss sich nur darum
kümmern, dass das
Plugin auch verfügbar ist.

23. <plugin>
<groupId>org.jvnet.jaxb2.maven2</groupId>
<artifactId>maven-jaxb2-plugin</artifactId>
<executions>
<execution>
<id>ESB_Model</id>
<phase>generate-sources</phase>
<goals>
<goal>generate</goal>
</goals>
<configuration>
<schemaIncludes>
<include>**/*.xsd</include>
</schemaIncludes>
<schemaDirectory>src/main/resources/de/qaware/esb/commercial/xsd</schemaDirectory>
<generatePackage>de.qaware.esb.commercial.model</generatePackage>
<forceRegenerate>true</forceRegenerate>
<extension>true</extension>
<args>
<arg>-Xxew</arg>
<arg>-Xxew:instantiate lazy</arg>
</args>
. . .
case ANT_TASK_EXISTIERT:
23
Wir generieren an vielen Stellen
Resourcen aus WSDLs oder XSDs
über Maven Plugins
Einen gleichwertigen
Gradle-Ersatz haben
wir nicht gefunden

24. class XSD2JavaTask extends DefaultTask {
{...}
@TaskAction
public void generateSourcesFromXSD() {
ant.taskdef(
name: 'xjc',
classname: 'com.sun.tools.xjc.XJCTask',
classpath: project.configurations.jaxb.asPath
)
ant.xjc(
removeOldOutput: 'yes',
destdir: outputDir,
package: packageName,
extension: extension
) {
schema(dir: schemaDirPath, includes: '**/*.xsd')
if (extension) classpath(path: project.configurations.xjc.asPath)
for (argument in arguments) {arg(line: argument)}
}
}
}
case ANT_TASK_EXISTIERT:
24
Wir schreiben einen
CustomTask und
binden den Ant-Task
ein
Wir machen eigentlich
das Gleiche wie das
Maven Plugin

25. apply plugin: 'xsd2java'
import com.bmw.iap.april.plugins.xjc.tasks.XSD2JavaTask
task generateESBModelSources(type: XSD2JavaTask) {
schemaDirPath = "src/main/resources/de/qaware/demo/esb/commercial/xsd"
packageName = „de.qaware.demo.esb.model"
extension = true
arguments.add("-Xxew")
arguments.add("-Xxew:instantiate lazy")
}
compileJava {
dependsOn generateAPRILModelSources
source generateAPRILModelSources.outputDir
}
case ANT_TASK_EXISTIERT:
25
Im Build binden wir
den Task dann richtig
konfiguriert ein

26. Und wenn
es noch gar
nichts gibt,
bauen wir
es selbst.
Foto: Martin Poole

27. Sind wir schon da?
27
Foto: Mike Powell
Code kompiliert & Tests laufen
Dependencies sind überführt
Alle Plugins sind migriert
Spezialaufgaben4

28. Was machen wir mit den Profilen?
28
Wir erstellen für jedes
Profil ein eigenes Build-
Skript
Über eine Variable
aktivieren wir das
gewünschte Profil

29. Jetzt sind wir da!
29
Foto: Mike Powell
Code kompiliert & Tests laufen
Dependencies sind überführt
Alle Plugins sind migriert
Spezialaufgaben

30. Stolperfallen
Foto: James Woodson

31. Dependencies!
Foto: stevecoleimages – gettyimages.de

32. Bauen kann man
alles…
Foto: Martin Poole

33. task generateServiceClassesPortalIntegrationProviderServiceV2(type: WSDL2JavaTask) {
ext {
wsdl = "$projectDir/src/main/resources/PortalIntegrationProviderService_v2.wsdl"
sourceRoot = file("$buildDir/generated-sources/cxf")
location = "PortalIntegrationProviderService_v2.wsdl"
}
args '-wsdlLocation', location
args '-d', sourceRoot
args '-client'
args '-verbose'
args wsdl
}
compileJava{
dependsOn generateServiceClassesPortalIntegrationProviderServiceV2
source generateServiceClassesPortalIntegrationProviderServiceV2.sourceRoot
}
Wenn man nicht aufpasst, kann man die Performance-
Vorteile von Gradle sehr schnell verlieren.
33
Task „wsdl2java“ wird
in jedem Build
ausgeführt
Dadurch ändern sich für
Gradle die generierten
Klassen
Das ganze Modul wird
neu gebaut
Alle Tests werden
nochmal ausgeführt.
Der Build dauert
genauso lange wie mit
Maven.

34. task generateServiceWsdlV2(type: Java2WSTask) {
description = 'Generate the ServiceWsdl resources'
ext {
className = 'de.qaware.esb.integration.PortalIntegrationServiceV2'
outputDir = "$generatedResourcesDir/META-INF/wsdl"
outputFile = 'PortalIntegrationService_v2.wsdl'
inputClasspath = "$buildDir/classes/main"
}
mkdir(outputDir)
inputs.dir(outputDir)
args '-d', file(outputDir)
args '-cp',"$buildDir/classes/java/main"
args '-o', outputFile
args '-verbose'
args '-wsdl'
args className
}
Wir lösen das Problem über definierte Inputs & Outputs
34

35. Hat es sich
gelohnt?
Foto: RichVintage – gettyimages.de

36. Foto: RichVintage – gettyimages.de
Ist Gradle wirklich so
viel schneller? Revision
ESB
Buildzeit in Sekunden
mvn install
–DskipTests
Buildzeit in Sekunden
gradlew build –x test
–x integrationTest
315537 44,72 14
315577 43,67 15
315598 45,01 13
315664 41,91 14
315668 44,67 5
315701 41,66 5
315724 41,67 6
315854 44,24 15
315948 41,29 13
315949 41,45 13
315951 41,92 13
315952 40,47 13
316029 41,93 13
316040 41,53 13
316069 58,90 5
Ø = 43,67 Ø = 11,33
Ja, ist es:
Mal wieder etwas
Neues ausprobieren
wäre nett.
Ja, war es!
Wäre eine gute
Einstiegsaufgabe…
Die Generierung der
Reports lässt sich in
Gradle sehr einfach
konfigurieren.

37. QAware GmbH München
Aschauer Straße 32
81549 München
Tel.: +49 (0) 89 23 23 15 – 0
Fax: +49 (0) 89 23 23 15 – 129 github.com/qaware
linkedin.com/qaware slideshare.net/qaware
twitter.com/qaware xing.com/qaware