Building Groovy Applications Sample
You can open this sample in an IDE that supports Gradle. |
This guide demonstrates how to create a Groovy application with Gradle using gradle init
.
You can follow the guide step-by-step to create a new project from scratch or download the complete sample project using the links above.
What you’ll build
You’ll generate a Groovy application that follows Gradle’s conventions.
What you’ll need
-
A text editor or IDE - for example IntelliJ IDEA
-
A Java Development Kit (JDK), version 8 or higher - for example AdoptOpenJDK
-
The latest Gradle distribution
Create a project folder
Gradle comes with a built-in task, called init
, that initializes a new Gradle project in an empty folder.
The init
task uses the (also built-in) wrapper
task to create a Gradle wrapper script, gradlew
.
The first step is to create a folder for the new project and change directory into it.
$ mkdir demo $ cd demo
Run the init task
From inside the new project directory, run the init
task using the following command in a terminal: gradle init
.
When prompted, select the 1: application
project type and 3: Groovy
as implementation language.
Next you can choose the DSL for writing buildscripts - 1 : Groovy
or 2: Kotlin
.
For the other questions, press enter to use the default values.
The output will look like this:
$ gradle init Select type of project to generate: 1: basic 2: application 3: library 4: Gradle plugin Enter selection (default: basic) [1..4] 1 Select implementation language: 1: C++ 2: Groovy 3: Java 4: Kotlin 5: Scala 6: Swift Enter selection (default: Java) [1..6] 3 Select build script DSL: 1: Groovy 2: Kotlin Enter selection (default: Groovy) [1..2] 1 Project name (default: demo): Source package (default: demo): BUILD SUCCESSFUL 2 actionable tasks: 2 executed
The init
task generates the new project with the following structure:
├── gradle (1)
│ ├── libs.versions.toml (2)
│ └── wrapper
│ ├── gradle-wrapper.jar
│ └── gradle-wrapper.properties
├── gradlew (3)
├── gradlew.bat (3)
├── settings.gradle.kts (4)
└── app
├── build.gradle.kts (5)
└── src
├── main
│ └── groovy (6)
│ └── demo
│ └── App.groovy
└── test
└── groovy (7)
└── demo
└── AppTest.groovy
├── gradle (1)
│ ├── libs.versions.toml (2)
│ └── wrapper
│ ├── gradle-wrapper.jar
│ └── gradle-wrapper.properties
├── gradlew (3)
├── gradlew.bat (3)
├── settings.gradle (4)
└── app
├── build.gradle (5)
└── src
├── main
│ └── groovy (6)
│ └── demo
│ └── App.groovy
└── test
└── groovy (7)
└── demo
└── AppTest.groovy
1 | Generated folder for wrapper files |
2 | Generated version catalog |
3 | Gradle wrapper start scripts |
4 | Settings file to define build name and subprojects |
5 | Build script of app project |
6 | Default Groovy source folder |
7 | Default Groovy test source folder |
You now have the project setup to build a Groovy application.
Review the project files
The settings.gradle(.kts)
file has two interesting lines:
rootProject.name = "demo"
include("app")
rootProject.name = 'demo'
include('app')
-
rootProject.name
assigns a name to the build, which overrides the default behavior of naming the build after the directory it’s in. It’s recommended to set a fixed name as the folder might change if the project is shared - e.g. as root of a Git repository. -
include("app")
defines that the build consists of one subproject calledapp
that contains the actual code and build logic. More subprojects can be added by additionalinclude(…)
statements.
Our build contains one subproject called app
that represents the Groovy application we are building.
It is configured in the app/build.gradle(.kts)
file:
plugins {
groovy (1)
application (2)
}
repositories {
mavenCentral() (3)
}
dependencies {
implementation(libs.groovy.all) (4)
implementation(libs.guava) (5)
testImplementation(libs.spock.core) (6)
testImplementation(libs.junit)
testRuntimeOnly("org.junit.platform:junit-platform-launcher")
}
application {
mainClass = "demo.App" (7)
}
tasks.named<Test>("test") {
useJUnitPlatform() (8)
}
plugins {
id 'groovy' (1)
id 'application' (2)
}
repositories {
mavenCentral() (3)
}
dependencies {
implementation libs.groovy.all (4)
implementation libs.guava (5)
testImplementation libs.spock.core (6)
testImplementation libs.junit
testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
}
application {
mainClass = 'demo.App' (7)
}
tasks.named('test') {
useJUnitPlatform() (8)
}
1 | Apply the groovy Plugin to add support for Groovy. |
2 | Apply the application plugin to add support for building a CLI application in Java. |
3 | Use Maven Central for resolving dependencies. |
4 | Use the latest Groovy version for building this library |
5 | This dependency is used by the application. |
6 | Use the awesome Spock testing and specification framework even with Java |
7 | Define the main class for the application. |
8 | Use JUnit Platform for unit tests. |
The file src/main/groovy/demo/App.groovy
is shown here:
/*
* This source file was generated by the Gradle 'init' task
*/
package demo
class App {
String getGreeting() {
return 'Hello World!'
}
static void main(String[] args) {
println new App().greeting
}
}
The generated test, src/test/groovy/demo/App.groovy
is shown next:
/*
* This source file was generated by the Gradle 'init' task
*/
package demo
import spock.lang.Specification
class AppTest extends Specification {
def "application has a greeting"() {
setup:
def app = new App()
when:
def result = app.greeting
then:
result != null
}
}
The generated test class has a single Spock test.
The test instantiates the App
class, invokes a method on it, and checks that it returns the expected value.
Run the application
Thanks to the application
plugin, you can run the application directly from the command line.
The run
task tells Gradle to execute the main
method in the class assigned to the mainClass
property.
$ ./gradlew run > Task :app:run Hello world! BUILD SUCCESSFUL 2 actionable tasks: 2 executed
The first time you run the wrapper script, gradlew , there may be a delay while that version of gradle is downloaded and stored locally in your ~/.gradle/wrapper/dists folder.
|
Bundle the application
The application
plugin also bundles the application, with all its dependencies, for you.
The archive will also contain a script to start the application with a single command.
$ ./gradlew build BUILD SUCCESSFUL in 0s 7 actionable tasks: 7 executed
If you run a full build as shown above, Gradle will have produced the archive in two formats for you:
app/build/distributions/app.tar
and app/build/distributions/app.zip
.
Publish a Build Scan
The best way to learn more about what your build is doing behind the scenes, is to publish a build scan.
To do so, just run Gradle with the --scan
flag.
$ ./gradlew build --scan BUILD SUCCESSFUL in 0s 7 actionable tasks: 7 executed Publishing a build scan to scans.gradle.com requires accepting the Gradle Terms of Service defined at https://gradle.com/terms-of-service. Do you accept these terms? [yes, no] yes Gradle Terms of Service accepted. Publishing build scan... https://gradle.com/s/5u4w3gxeurtd2
Click the link and explore which tasks where executed, which dependencies where downloaded and many more details!
Summary
That’s it! You’ve now successfully configured and built a Groovy application project with Gradle. You’ve learned how to:
-
Initialize a project that produces a Groovy application
-
Run the build and view the test report
-
Execute a Groovy application using the
run
task from theapplication
plugin -
Bundle the application in an archive
Next steps
To learn more about how you can further customize Groovy application projects, check out the following user manual chapters: