1. Projects
A project in Gradle represents a logical unit of work. It can be as small as a single module of code or as large as a multi-module system. Each project is defined by a build.gradle
file.
Structure
- Single-Project Build: Consists of a single project.
- Multi-Project Build: Consists of a root project and one or more sub-projects. Each project has its own
build.gradle
file, and the root project has asettings.gradle
file that includes the sub-projects.
Example
Single-Project Build
// build.gradle
plugins {
id 'java'
}
repositories {
mavenCentral()
}
dependencies {
implementation 'com.google.guava:guava:31.0.1-jre'
}
task hello {
doLast {
println 'Hello, World!'
}
}
Multi-Project Build
// settings.gradle
rootProject.name = 'multi-project-example'
include 'subproject1', 'subproject2'
// Root project's build.gradle
subprojects {
apply plugin: 'java'
repositories {
mavenCentral()
}
}
// subproject1/build.gradle
dependencies {
implementation 'com.google.guava:guava:31.0.1-jre'
}
// subproject2/build.gradle
dependencies {
implementation 'org.apache.commons:commons-lang3:3.12.0'
}
2. Tasks
A task represents a piece of work that a build performs. Examples include compiling classes, running tests, and packaging JAR files.
Creating Tasks
Tasks can be defined in the build script using the task
keyword.
Example
task hello {
doLast {
println 'Hello, World!'
}
}
task compile(type: JavaCompile) {
source = fileTree('src/main/java')
destinationDir = file('build/classes')
classpath = files()
}
In this example, the hello
task prints "Hello, World!" to the console, and the compile
task compiles Java source files.
3. Plugins
Plugins extend Gradle's capabilities by adding new tasks, configurations, and conventions. There are two types of plugins: core plugins (provided by Gradle) and community plugins (provided by the community).
Applying Plugins
Plugins can be applied using the plugins
or apply
keyword.
Example
plugins {
id 'java'
id 'application'
}
application {
mainClassName = 'com.example.Main'
}
In this example, the java
and application
plugins are applied. The application
plugin requires specifying the main class of the application.
4. Configurations
Configurations are a way to define a set of dependencies. They play a crucial role in dependency management.
Example
configurations {
implementation
testImplementation
}
dependencies {
implementation 'com.google.guava:guava:31.0.1-jre'
testImplementation 'org.junit.jupiter:junit-jupiter:5.9.3'
}
In this example, the implementation
configuration is used for dependencies required to compile the production code, and the testImplementation
configuration is used for dependencies required to compile the test code.
5. Dependency Management
Gradle uses configurations to manage dependencies, which can be external libraries, other projects, or files.
Example
repositories {
mavenCentral()
}
dependencies {
implementation 'com.google.guava:guava:31.0.1-jre'
testImplementation 'org.junit.jupiter:junit-jupiter:5.9.3'
}
In this example, dependencies are declared in the dependencies
block, and repositories are specified in the repositories
block. The mavenCentral()
repository is used to fetch the dependencies.
6. Gradle Wrapper
The Gradle Wrapper is a script that allows you to run a specific version of Gradle without requiring that Gradle is installed on your system.
Creating the Wrapper
gradle wrapper --gradle-version 8.0.2
Using the Wrapper
./gradlew build
The gradlew
script ensures that the correct version of Gradle is used for the project, which is particularly useful for continuous integration and sharing projects.
7. Build Script Basics
Groovy vs. Kotlin DSL
Gradle build scripts can be written in Groovy (build.gradle) or Kotlin (build.gradle.kts). The choice between them depends on your preference for a dynamic or statically typed language.
Example (Groovy)
plugins {
id 'java'
}
repositories {
mavenCentral()
}
dependencies {
implementation 'com.google.guava:guava:31.0.1-jre'
}
task hello {
doLast {
println 'Hello, World!'
}
}
Example (Kotlin)
plugins {
java
}
repositories {
mavenCentral()
}
dependencies {
implementation("com.google.guava:guava:31.0.1-jre")
}
tasks.register("hello") {
doLast {
println("Hello, World!")
}
}
8. Custom Tasks
Custom tasks allow you to define specific actions that are not covered by the standard Gradle tasks.
Example
task copyFiles(type: Copy) {
from 'src/main/resources'
into 'build/resources'
}
In this example, the copyFiles
task copies files from src/main/resources
to build/resources
.
Conclusion
Understanding these core concepts of Gradle will help you get the most out of this powerful build automation tool. Whether you're working on a simple project or a complex multi-module system, mastering these concepts will enable you to manage your builds and dependencies efficiently.
For more detailed information, visit the official Gradle documentation. Happy building!
Comments
Post a Comment
Leave Comment