2. What is Gradle?
Gradle is a general purpose build system
It comes with a rich build description
language (DSL) based on Groovy
It supports ”build-by-convention” principle
But it is very flexible and extensible
It has built-in plug-ins for Java, Groovy,
Scala, Web, OSGi
It derives all the best and integrates well
with Ivy, Ant and Maven
3. What’s in this presentation?
Overview
Basic features & principles
Files and file collections
Dependencies
Multiple projects
Plug-ins
Reading material
Questions
5. Gradle features I
Declarative builds and build-by-
convention
Language for dependency based
programming and many ways to
manage dependencies
Groovy as a base language allows
imperative programming
6. Gradle features II
Deep and rich API for managing
projects, tasks, dependency
artefacts and much more.
State of the art support for multi-
project builds
Ease of integration and migration.
Ant, Maven, Ivy are supported out-
of-the-box
Free and open source
7. Advanced features
Parallel unit test execution
Dependency build
Incremental build support
Dynamic tasks and task rules
Gradle daemon
8. Who uses Gradle?
Hibernate Canoo
Grails Carrier
Groovy FCC
Spring Integration Zeppelin
Spring Security GPars
Griffon Spock
Gaelyk Aluminum
Qi4j Gant
16. Ant is a first-class citizen
All Ant tasks and types can be used
inside Gradle script using Groovy
syntax
Whole Ant build script can be
imported into Gradle and its targets
can be called
17. Ant usage examples I
task hello << {
String greeting = "hello from Ant"
ant.echo(message: greeting)
}
task list << {
def path = ant.path {
fileset(dir: 'libs', includes: '*.jar')
}
path.list().each {
println it
}
}
task zip << {
ant.zip(destfile: 'archive.zip') {
fileset(dir: 'src') {
include(name: '**.xml')
exclude(name: '**.java')
}
}
}
18. Ant usage examples II
ant.taskdef(resource: 'checkstyletask.properties') {
classpath {
fileset(dir: 'libs/checkstyle', includes: '*.jar')
}
}
ant.checkstyle(config: 'src/tools/sun_checks.xml') {
fileset(dir: 'src')
}
<project>
<target name="hello">
<echo>Hello, from Ant</echo>
</target>
</project> >gradle hello
:hello
[ant:echo] Hello, from Ant
ant.importBuild 'build.xml' BUILD SUCCESSFUL
Total time: 7.898 secs
19. Overriding conventions
version = 1.0
group = ’org.gradletutorials’
version = "1.0-${new Date().format('yyyyMMdd')}"
task release(dependsOn: assemble) << {
println 'We release now'
}
build.taskGraph.whenReady { taskGraph ->
if (taskGraph.hasTask(':release')) {
version = '1.0’
} else {
version = '1.0-SNAPSHOT’
}
}
sourceSets.main.java.srcDirs += ["src/generated/java"]
sourceSets.main.resources.srcDirs += ["src/generated/resources"]
20. More examples
Many source directory sets per
project without a need of a plug-in
Different dependencies per source
directory
Even different JDK per source
directory
Many artifacts per project
22. Referencing files & file collections
Groovy-like syntax:
// Using a relative path
File configFile = file('src/config.xml')
Create a file collection from a bunch of files:
FileCollection collection = files(
'src/file1.txt',
new File('src/file2.txt'),
['src/file3.txt', 'src/file4.txt'])
Create a files collection by referencing project properties:
collection = files { srcDir.listFiles() }
Operations on collections:
def union = collection + files('src/file4.txt')
def different = collection - files('src/file3.txt')}
23. Using file collections as input
Many objects in Gradle have properties, which accept a set of
input files. For example, the compile task has a source property,
which defines the source files to compile. You can set the value
of this property using any of the types supported by the files()
method:
// Use a File object to specify the source directory.
compile {
source = file('src/main/java')
}
// Using a closure to specify the source files.
compile {
source = {
// Use the contents of each zip file in the src dir.
file('src')
.listFiles()
.findAll { it.name.endsWith('.zip') }
.collect { zipTree(it) }
}
}
}1
24. Copying files
Using Ant integration:
ant.copy(todir: 'javadoc') {
fileset(dir: 'build/docs')
}
Using Gradle task type:
task copyTask(type: Copy) {
from 'src/main/webapp‘
into 'build/explodedWar‘
include '**/*.jsp‘
exclude { details ->
details.file.name.endsWith('.html') &&
details.file.text.contains('staging')
}
}
30. Directories & settings.gradle
settings.gradle:
include 'shared', 'api', ':service:service1', ':service:service2'
You can have only one build file
for the whole multi-project build
All properties, settings, plug-ins,
dependencies are derived without
a need to duplicate information
You can override almost all
behaviour in child builds
31. All or something
allprojects {
task build << {
println "Building project: " + project.name
}
} >gradle build
:build
subprojects { Building project: 90-multi-project
task prebuild << { :api:prebuild
println "It is subproject!" It is subproject!
:api:build
} Building project: api
build.dependsOn prebuild :service:prebuild
} It is subproject!
:service:build
Building project: service
:shared:prebuild
It is subproject!
:shared:build
Building project: shared
:service:service1:prebuild
It is subproject!
:service:service1:build
Building project: service1
:service:service2:prebuild
It is subproject!
:service:service2:build
Building project: service2
BUILD SUCCESSFUL
Total time: 9.684 secs
34. Extending your build
Any Gradle script can be a plug-in:
apply from: 'otherScript.gradle'
apply from: 'http://mycomp.com/otherScript.gradle'
Use many of the standard or 3rd-party plug-ins:
apply plugin: 'java'
apply plugin: 'groovy'
apply plugin: 'scala'
apply plugin: 'war'
Configuration objects can be externalized:
task configure << {
pos = new java.text.FieldPosition(10)
// Apply the script.
apply from: 'position.gradle', to: pos
println pos.beginIndex
println pos.endIndex
position.gradle:
}
beginIndex = 1;
endIndex = 5;
35. Standard plug-ins
Plug-in ID Plug-in ID
base application (java, groovy)
java-base jetty (war)
groovy-base maven (java, war)
scala-base osgi (java-base, java)
reporting-base war (java)
java (java-base) code-quality (reporting-base, java,
groovy)
groovy (java, groovy-base) eclipse (java, groovy, scala, war)
scala (java, scala-base) idea (java)
antlr (java) project-report (reporting-base)
announce sonar
38. Literature
“Build and test software written in Java and
many other languages with Gradle, the open
source project automation tool that’s getting
a lot of attention. This concise introduction
provides numerous code examples to help
you explore Gradle, both as a build tool and
as a complete solution for automating the
compilation, test, and release process of
simple and enterprise-level applications .”
http://shop.oreilly.com/product/0636920019909.do
