> For the complete documentation index, see [llms.txt](https://codewithmeiy.gitbook.io/core-java/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://codewithmeiy.gitbook.io/core-java/build-architectures/gradle.md).

# Gradle

Gradle is an open-source build automation tool that is used for building, testing, and deploying software projects. It uses a Groovy-based domain-specific language (DSL) for build scripts, but it also supports the Kotlin DSL. Gradle is highly customizable and provides a powerful and flexible build system for various types of projects, including Java applications.

### Gradle Installation

Before setting up a Gradle project, you need to install Gradle on your system.

#### Installation on Windows

1. **Download Gradle:**
   * Visit the official Gradle website at <https://gradle.org/install/>.
   * Download the latest binary distribution for Windows.
2. **Extract Gradle:**
   * Create a directory for Gradle (e.g., `C:\Gradle`).
   * Extract the contents of the downloaded Gradle distribution zip file to this directory.
3. **Set Environment Variables:**
   * Add the Gradle `bin` directory to your system's PATH environment variable.
4. **Verify Installation:**
   * Open a command prompt and run `gradle -v` to ensure Gradle is installed correctly.

#### Installation on macOS and Linux

1. **Install SDKMAN! (Optional):**
   * On macOS and Linux, you can use [SDKMAN!](https://sdkman.io/) to manage Gradle installations easily.
2. **Install Gradle using SDKMAN!:**

   * Open your terminal and run the following command to install Gradle using SDKMAN!:

   ```bash
   sdk install gradle
   ```
3. **Verify Installation:**
   * Run `gradle -v` to verify the installation.

### Gradle Project Structure

A typical Gradle project structure consists of the following directories and files:

* `src/` - This directory contains your project's source code.
* `build/` - Gradle generates build outputs and intermediate files in this directory.
* `build.gradle` - The build script for your project, written in Groovy or Kotlin DSL.
* `settings.gradle` - This file configures the project's settings, such as its name and dependencies.

### Example Gradle Project

Let's create a simple Java project using Gradle to illustrate the project structure and build script.

#### Creating a New Gradle Project

1. **Create a Project Directory:**
   * Create a new directory for your Gradle project. For example, `MyJavaProject`.
2. **Initialize Gradle Project:**

   * Open a terminal and navigate to the project directory.
   * Run the following command to initialize a new Gradle project:

   ```bash
   gradle init --type java-application
   ```

   This command will generate the basic project structure and build files.

#### Project Structure

After running the initialization command, your project structure should look like this:

```
MyJavaProject/
├── build/
├── gradle/
├── src/
│   ├── main/
│   │   └── java/
│   │       └── com/
│   │           └── myproject/
│   │               └── App.java
│   └── test/
│       └── java/
│           └── com/
│               └── myproject/
│                   └── AppTest.java
├── build.gradle
└── settings.gradle
```

#### Build Script

Open the `build.gradle` file in your project directory. This is where you define the project's dependencies and configurations. Below is a basic `build.gradle` example:

```groovy
plugins {
    id 'java'
}

repositories {
    jcenter()
}

dependencies {
    implementation 'org.slf4j:slf4j-api:1.7.32'
    implementation 'org.slf4j:slf4j-simple:1.7.32'
}

application {
    mainClassName = 'com.myproject.App'
}

test {
    useJUnitPlatform()
}
```

This script does the following:

* Applies the Java plugin.
* Configures repositories for resolving dependencies.
* Defines project dependencies (in this case, SLF4J).
* Specifies the main class for the application.
* Configures JUnit for testing.

### Building and Running the Project

Now that your Gradle project is set up, you can build and run it:

1. **Building the Project:**

   * Open a terminal and navigate to your project directory.
   * Run the following command to build the project:

   ```bash
   gradle build
   ```

   This command compiles your Java code and creates a JAR file in the `build/libs/` directory.
2. **Running the Application:**

   * Run your Java application with the following command:

   ```bash
   java -jar build/libs/MyJavaProject.jar
   ```

   Replace `MyJavaProject.jar` with the actual JAR file name.

That's it! You've successfully created a Gradle project, defined a build script, and built and executed your Java application using Gradle. Gradle's flexibility allows for more complex project configurations and builds, making it a powerful choice for Java development.