An introduction on maven, gradle and sbt. This presentation shows how to setup a project, manage dependencies and build it using automated tools

1. The Gangs of
Three
Ciao
ciao
Vai a fare
ciao ciao
Dr. Fabio Fumarola
Maven, Gradle and SBT

2. Java Project related questions
• How do we create a java project?
• How do we add dependencies?
• How do we create a runnable jar?
• How do we create a war?
• How do we execute tests?
2

3. Contents
• Maven
• Gradle
• Sbt
3

4. What is Maven?
• Apache Maven is a software project management.
• It is based on the concept of a Project Object Model
(POM)
• Maven can mange a project’s build, reporting a
documentation form a central piece of information
But it isn’t a mere build tool
4

5. Maven features
• Dependency System
• Multi-module builds
• Consistent project structure
• Consistent build model
• Plugin oriented
• Project generated sites
5

6. Advantages over Ant
• Eliminate complicate scripts
• All the functionality required to build your project,
i.e., clean, compile, copy, resources, install, deploy
• Cross Project Reuse – Ant has no convenient way to
reuse target across projects.
6

7. How Maven Works?
7

8. Maven keywords
• POM
• Archetype
• Artifact or dependency
• Plugin
• Goal
8

9. POM
• Unit of work in Maven
• It is an XML file that contains the information and
the configuration details used by Maven to build the
project
9

10. Archetype
• It is a template of a project with is combined with
some user input to produce a working Maven project
• There are hundreds of archetypes to help us get
started
– $ mvn –version
– $ mvn archetype:generate
-DgroupId=com.mycompany.app -DartifactId=my-app
-DarchetypeArtifactId=maven-archetype-quickstart
-DinteractiveMode=true
– $ mvn eclipse:eclipse
10

11. Artifact
• An artifact is a module obtained by another artifact
deployed to a maven repository
• Each artifact belongs to a group
• Each group can have more artifacts
11
<dependency>
<groupId>joda-time</groupId>
<artifactId>joda-time</artifactId>
<version>2.6</version>
</dependency>

12. Goals and Plugins
• Are an extension of the standard maven lifecycles
steps.
– Clean, compile, test, package, install and deploy
• There are plugin to do other steps such as
12
<plugins>
<plugin>
<artifactId>maven-assembly-plugin</artifactId>
<version>2.5.3</version>
<configuration>
<descriptorRefs>
<descriptorRef>jar-with-dependencies</descriptorRef>
</descriptorRefs>
</configuration>
[...]
</plugin> </plugins>

13. 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
• Groovy as a base language allows imperative
programming in the build file.
13

14. Advanced features
• Parallel unit test execution
• Dependency building
• Incremental build support
• Dynamic tasks and task rules
• Gradle daemon
14

15. Hello, Gradle
• Create a file build.gradle
task hello << {
println 'Hello World'
}
• Run $ gradle hello
• Edit the file as below
task hello << {
print 'Hello '
}
task world(dependsOn: hello) << {
println 'World!"
}
• Run $ gradle –q world
15

16. Build scripts are code
task upper << {
String someString = 'mY_nAmE'
println "Original: " + someString
println "Upper case: " + someString.toUpperCase()
}
- $gradle upper
4.times { counter ->
task "task$counter" << {
println "I'm task number $counter"
}
}
16

17. Gradle is Groovy that is Java
JAVA
import java.ioFile;
…
String parentDir = new File(“test.txt”).getAbsoluteFile()
.getParentPath();
Groovy
def parentDir = new File(“test.txt”).absoluteFile.parentPath
Gradle
parentDir = file(“test.txt”).absoluteFile.parentPath
17

18. Building a Java project
apply plugin: ‘java’
18

19. Gradle support all ant task
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')
} } }
19

20. Overriding conventions
Version = 1.0
Group = ‘org.mygroup’
task release(dependsOn: assemble) << {
println 'We release now'
}
build.taskGraph.whenReady { taskGraph -> if
(taskGraph.hasTask(':release')) {
version = '1.0’
} else {
version = '1.0-SNAPSHOT’ }
} 20

21. Referencing files & file
collections• Groovy-like syntax:
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() }
• Operation on collections
def union = collection + files('src/file4.txt')
def different = collection - files('src/file3.txt')}
21

22. Using file collections as input
• 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 = {
file(‘src’).listFiles()
.findAll { it.name.endsWith('.zip') }
.collect { zipTree(it) }
}
}
}
22

23. Copying files
• 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')
}
}
23

24. Dependency management
24

25. Repository configuration
• Remote Repos
repositories {
mavenCentral()
mavenCentral name: 'multi-jar-repos', urls:
["http://repo.mycompany.com/jars1",
"http://repo.mycompany.com/jars1"]
}
• Local Repos
repositories {
flatDir name: 'localRepository',
dirs: 'lib' flatDir dirs: ['lib1', 'lib2']
} 25

26. Referencing dependencies
dependencies {
runtime files('libs/a.jar', 'libs/b.jar’)
runtime fileTree(dir: 'libs', includes: ['*.jar'])
}
dependencies {
compile 'org.springframework:spring-webmvc:3.0.0.RELEASE'
testCompile 'org.springframework:spring-test:3.0.0.RELEASE'
testCompile 'junit:junit:4.7'
}
26

27. Referencing dependencies
List groovy = ["org.codehaus.groovy:groovy-all:1.5.4@jar",
"commons-cli:commons-cli:1.0@jar",
"org.apache.ant:ant:1.7.0@jar"]
List hibernate = ['org.hibernate:hibernate:3.0.5@jar',
'somegroup:someorg:1.0@jar']
dependencies {
runtime groovy, hibernate
}
27

28. Plugins
28

29. 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'
29

30. Standard plugins
30
http://www.gradle.org/docs/current/userguide/standard_plugins.html

31. Example java and scala project
• http://www.gradle.org/docs/current/userguide/tutorial_j
• http://www.gradle.org/docs/current/userguide/scala_plu
• http://plugins.gradle.org/
31

32. Sbt
The interactive build tool
32

33. Sbt
• It is a tool to define task and then run them from the
shell
• To install on linux grab the
– rpm: https://dl.bintray.com/sbt/rpm/sbt-0.13.7.rpm
– deb: https://dl.bintray.com/sbt/rpm/sbt-0.13.7.deb
33

34. Starting with sbt
• It is based on the file build.sbt
• Create a directory hello_scala
• Edit a file and add
lazy val root = (project in file(".")).
settings(
name.:=("hello”),
version := "1.0",
scalaVersion := "2.11.4"
)
• Create an HelloWorld class
34

35. Project Structure
• Sbt is base on maven project structure
35

36. Running sbt
• It has a shell via $sbt
• Or we can run task in batch
– $ sbt clean compile "testOnly TestA TestB”
• It also support continuos delivery and run via
– > ~compile
– > ~run
36

37. Creating a project definition
• To create a project in the build.sbt file
lazy val root = (project in file(.)).
settings(
organization := "com.example",
version := "0.1.0",
scalaVersion := "2.11.4"
)
• The build.sbt define a Project which holds a list of
scala expression called settings
• Moreover a build.sbt can have vals, lazy vals and defs
37

38. SettingKey, TaskKey and InputKey
lazy val root = (project in file(".")).
settings(
name.:=("hello")
)
•.:= is a method that takes a parameter and return s
Setting[String]
lazy val root = (project in file(".")).
settings(
name := 42 // will not compile
)
•Does it run?
38

39. Types of key
• SettingKey[T]: a key for a value computed once (the
value is computed when loading the project, and
kept around).
• TaskKey[T]: a key for a value, called a task, that has
to be recomputed each time, potentially with side
effects.
• InputKey[T]: a key for a task that has command line
arguments as input. Check out Input Tasks for more
details.
• The built-in key are field of the object Keys
(http://www.scala-
sbt.org/0.13/sxr/sbt/Keys.scala.html) 39

40. Custom Keys
• Can be created with their:
– settingKey, taskKey and inputKey
lazy val hello = taskKey[Unit](“An example task”)
• A TaskKey[T] can be used to define task such as
compile or package.
40

41. Defining tasks and settings
• For example, to implement the hello task
lazy val hello = taskKey[Unit]("An example task”)
lazy val root = (project in file(".")).
settings(
hello := { println("Hello!") }
)
• Imports in build.sbt
import sbt._
import Process._
import Keys._
41

42. Adding library dependencies
val derby = "org.apache.derby" % "derby" % "10.4.1.3"
lazy val commonSettings = Seq(
organization := "com.example",
version := "0.1.0",
scalaVersion := "2.11.4"
)
lazy val root = (project in file(".")).
settings(commonSettings: _*).
settings(
name := "hello",
libraryDependencies += derby
)
42

43. Dependencies
• To add an unmanaged dependency there is the task
unmanagedBase := baseDirectory.value / "custom_lib”
• To add an managed dependency there is the task
libraryDependencies += groupID % artifactID % revision
• Or
libraryDependencies ++= Seq(
groupID % artifactID % revision,
groupID % otherID % otherRevision
)
43

44. Resolvers
• To add a resolver
1. resolvers += name at location
2. resolvers += Resolver.mavenLocal
3. resolvers ++= Seq(name1 at location1, name2 at
location2)
• Is it possible also to define if the dependency is for
test
libraryDependencies += "org.apache.derby" % "derby" %
"10.4.1.3" % Test
44

45. Plugins
• To declare a plugin add a directory project/Build.sbt
45