{"id":556,"date":"2025-01-21T14:19:34","date_gmt":"2025-01-21T14:19:34","guid":{"rendered":"https:\/\/blog.ngocha.biz\/?p=556"},"modified":"2025-01-21T14:19:34","modified_gmt":"2025-01-21T14:19:34","slug":"build-java-application-using-gradle","status":"publish","type":"post","link":"https:\/\/blog.ngocha.biz\/?p=556","title":{"rendered":"How to Build Java Application Using Gradle?"},"content":{"rendered":"

In this blog, you will learn to build Java Application using Gradle.<\/p>\n

In this step-by-step blog, we will cover everything you need to know about building a Java Application using Gradle.<\/p>\n

What is Gradle?<\/h2>\n

Gradle<\/a> is an open-source build tool that automates the process of compiling, testing, and packaging the code, and its configuration files are written in Groovy.<\/p>\n

It supports almost every language but is mostly used for projects using languages like Java, Kotlin, C\/C++, etc.<\/p>\n

Gradle is highly customizable and supports a wide range of IDEs. IDE stands for an integrated development environment<\/code> which is software that combines the capability of compiling, testing and packaging applications.<\/p>\n

Why should we use Gradle?<\/h2>\n

Gradle is faster, highly scalable, and can be used to build large projects. For example, Netflix and Android are primarily built on Java, and they use Gradle as their building tool.<\/p>\n

Gradle was created to combine the advantages of Maven and Ant and also to reduce the issues while using them.<\/p>\n

For example, Maven and Ant build files are XML-based, which is a bit difficult to understand, but Gradle build files are based on Groovy or Kotlin, which is easily understandable.<\/p>\n

Maven rebuilds the whole project again for code changes, but Gradle only rebuilds the part where the code is changed. This is one of the main advantages of Gradle, which decreases build time.<\/p>\n

Gradle supports multi-project builds, which means it can split large projects into subprojects with its own build files. An example multi-project structure is given below:<\/p>\n

ecommerce\/\n\u251c\u2500\u2500 settings.gradle\n\u251c\u2500\u2500 build.gradle\n\u251c\u2500\u2500 web\/\n\u2502   \u2514\u2500\u2500 build.gradle\n\u251c\u2500\u2500 service\/\n\u2502   \u2514\u2500\u2500 build.gradle\n\u2514\u2500\u2500 data\/\n    \u2514\u2500\u2500 build.gradle<\/code><\/pre>\n
Prerequisites<\/h2>\n
To build a Java application with Gradle, you need the following installed on your system.<\/p>\n
    \n
  1. Java JDK<\/a><\/li>\n
  2. Gradle<\/a><\/li>\n<\/ol>\n
    How to Build Java Application Using Gradle?<\/h2>\n
    To build a simple Java application, clone the following repository to your workspace.<\/p>\n
    git clone https:\/\/github.com\/techiescamp\/java-app.git<\/code><\/pre>\n
    The structure of the repository is given below.<\/p>\n
    .\n\u251c\u2500\u2500 README.md\n\u251c\u2500\u2500 .github\n\u251c\u2500\u2500 build.gradle\n\u251c\u2500\u2500 pom.xml\n\u251c\u2500\u2500 settings.gradle\n\u2514\u2500\u2500 src\n    \u251c\u2500\u2500 main\n    \u2502   \u2514\u2500\u2500 java\n    \u2502       \u2514\u2500\u2500 springboot\n    \u2502           \u2514\u2500\u2500 Application.java\n    \u2514\u2500\u2500 test\n        \u2514\u2500\u2500 java\n            \u2514\u2500\u2500 springboot\n                \u2514\u2500\u2500 ApplicationTest.java<\/code><\/pre>\n
    The build.gradle<\/code> file contains all the requirements for the application, like plugins, dependencies, and the repository where the dependencies are downloaded from.<\/p>\n
    plugins {\n    id 'org.springframework.boot' version '3.4.1'\n    id 'io.spring.dependency-management' version '1.1.7'\n    id 'java'\n}\n\ngroup = 'springboot'\nversion = '1.0.0-SNAPSHOT'\n\nrepositories {\n    mavenCentral()\n}\n\ndependencies {\n    implementation 'org.springframework.boot:spring-boot-starter-web'\n    testImplementation 'org.springframework.boot:spring-boot-starter-test'\n}\n\njava {\n    toolchain {\n        languageVersion = JavaLanguageVersion.of(21)\n    }\n}\n\ntest {\n    useJUnitPlatform()\n}<\/code><\/pre>\n
      \n
    1. The plugin<\/code> block configures the springframework, dependency-management, and Java plugins to the application for springboot and dependency management.<\/li>\n
    2. In the group<\/code> and version<\/code>, we specify the project ID and version.<\/li>\n
    3. The repositories<\/code> block specifies the repository from which the dependencies will be downloaded, in this case it mavenCentral<\/code> repository.<\/li>\n
    4. In the dependencies<\/code> block, we specify the dependencies needed, this downloads the springboot starter web<\/code> dependency for web applications and the springboot starter test<\/code> for testing.<\/li>\n
    5. In the Java toolchain<\/code> block, we specify the required Java version.<\/li>\n
    6. In the final test<\/code> block, we specify the JUnitPlatform<\/code> for running the test case.<\/li>\n<\/ol>\n
      The settings.gradle<\/code> file is where the root project name is specified.<\/p>\n
      rootProject.name = 'spring-boot'<\/code><\/pre>\n
      The src<\/strong> folder contains two subfolders, main<\/strong> and test<\/strong>. The main\/java\/springboot<\/strong> folder contains the application’s source code.<\/p>\n
      package springboot;\n\nimport org.springframework.boot.SpringApplication;\nimport org.springframework.boot.autoconfigure.SpringBootApplication;\nimport org.springframework.web.bind.annotation.GetMapping;\nimport org.springframework.web.bind.annotation.RestController;\n\n@SpringBootApplication\n@RestController\npublic class Application {\n\n    public static void main(String[] args) {\n        SpringApplication.run(Application.class, args);\n    }\n\n    @GetMapping(\"\/\")\n    public String index() {\n        return \"Hi from Spring Boot\";\n    }\n}<\/code><\/pre>\n
      It is a simple spring boot application that says “Hi from Spring Boot” while we run.<\/p>\n
      The test\/java\/springboot<\/strong> folder contains the test case for source code.<\/p>\n
      package springboot;\n\nimport org.junit.jupiter.api.Test;\nimport org.springframework.beans.factory.annotation.Autowired;\nimport org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;\nimport org.springframework.boot.test.context.SpringBootTest;\nimport org.springframework.test.web.servlet.MockMvc;\n\nimport static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;\nimport static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content;\nimport static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;\n\n@SpringBootTest\n@AutoConfigureMockMvc\npublic class ApplicationTest {\n\n    @Autowired\n    private MockMvc mockMvc;\n\n    @Test\n    public void indexEndpointReturnsExpectedMessage() throws Exception {\n        mockMvc.perform(get(\"\/\"))\n                .andExpect(status().isOk())\n                .andExpect(content().string(\"Hi from Spring Boot\"));\n    }\n}<\/code><\/pre>\n
      This test checks if the endpoint returns HTTP 200 status with the expected message “Hi from Spring Boot.”<\/p>\n
      The pom.xml<\/code> file is used when you build the Java application using Maven<\/a>, not when building with Gradle.<\/p>\n
      pom.xml<\/code> is a similar file like build.gradle<\/code>, it contains all the requirements for the application, like plugins, dependencies, etc…<\/p>\n
      pom.xml<\/code> is for building Java applications using Maven and build.gradle<\/code> is for building Java applications using Gradle.<\/p>\n
      Let’s start building the Java application using Gradle, go to the root directory using the following command.<\/p>\n
      cd java-app<\/code><\/pre>\n
      Before building the application, you can check if the application is working properly by running the following command from the root directory, which is java-app<\/strong>.<\/p>\n
      gradle bootRun<\/code><\/pre>\n
      This runs your application, and you can access it on the web using the URL http:\/\/localhost:8080<\/a>.<\/p>\n
      Now, run the following command from the root directory to build the application using Gradle.<\/p>\n
      gradle build<\/code><\/pre>\n
      Once the build is completed, you can find the JAR file inside the build\/libs\/<\/strong> directory as shown below.<\/p>\n
      \"jar<\/figure>\n
      To run the JAR file, run the following command.<\/p>\n
      java -jar build\/libs\/spring-boot-1.0.0-SNAPSHOT.jar<\/code><\/pre>\n
      You can add the symbol & at the end of the above command to run the application in the background.<\/p>\n
      Once, it starts running you can access the application on the web using the URL http:\/\/localhost:8080<\/a>, as shown below<\/p>\n
      \"accessing<\/figure>\n
      You can use this JAR file to create a dockerized<\/a> image of the Java application and deploy the Java application on Kubernetes<\/a>.<\/p>\n
      Gradle Commands<\/h2>\n
      Let’s look at other important Gradle commands that are not used in the example.<\/p>\n
      Init Command<\/h3>\n
      The init command will create a basic project structure with every configuration file based on the project type you select.<\/p>\n
      Run the following command to create the project structure.<\/p>\n
      gradle init<\/code><\/pre>\n
      This will ask a couple of questions to create the structure as shown below.<\/p>\n
      \"questions<\/figure>\n
      Once you answer all the questions, your new project structure will be created based on your answers.<\/p>\n
      .\n\u251c\u2500\u2500 app\n\u2502   \u251c\u2500\u2500 build.gradle\n\u2502   \u2514\u2500\u2500 src\n\u2502       \u251c\u2500\u2500 main\n\u2502       \u2502   \u251c\u2500\u2500 java\n\u2502       \u2502   \u2502   \u2514\u2500\u2500 org\n\u2502       \u2502   \u2502       \u2514\u2500\u2500 example\n\u2502       \u2502   \u2502           \u2514\u2500\u2500 App.java\n\u2502       \u2502   \u2514\u2500\u2500 resources\n\u2502       \u2514\u2500\u2500 test\n\u2502           \u251c\u2500\u2500 java\n\u2502           \u2502   \u2514\u2500\u2500 org\n\u2502           \u2502       \u2514\u2500\u2500 example\n\u2502           \u2502           \u2514\u2500\u2500 AppTest.java\n\u2502           \u2514\u2500\u2500 resources\n\u251c\u2500\u2500 gradle\n\u2502   \u251c\u2500\u2500 libs.versions.toml\n\u2502   \u2514\u2500\u2500 wrapper\n\u2502       \u251c\u2500\u2500 gradle-wrapper.jar\n\u2502       \u2514\u2500\u2500 gradle-wrapper.properties\n\u251c\u2500\u2500 gradle.properties\n\u251c\u2500\u2500 gradlew\n\u251c\u2500\u2500 gradlew.bat\n\u2514\u2500\u2500 settings.gradle<\/code><\/pre>\n
      Gradle Scan Command<\/h3>\n
      The Gradle scan command records the details of your build, such as execution time, plugins and dependencies used, etc… and shows it on the web.<\/p>\n
      To use Gradle scan, you have to use the --scan<\/code> flag with the build command as given below.<\/p>\n
      gradle build --scan<\/code><\/pre>\n
      Once the build is completed, it will ask a question whether your want to see the details of your build in the web, if you say yes, it will generate a link to access the page.<\/p>\n
      \"\"<\/figure>\n
      Then you have to give your Email ID on the page that appears when you press the above link, it will send the web page link to the specified ID.<\/p>\n
      Then, you can use the link from the Email to view the below page.<\/p>\n
      \"web<\/figure>\n
      Gradle Profile Command<\/h3>\n
      The profile command created a detailed report of the build in an HTML file, but not as detailed as the scan command.<\/p>\n
      This command is helpful in generating build reports on CI\/CD workflows.<\/p>\n
      To use the Gradle profile, you have to use the --profile<\/code> flag with the build command as given below.<\/p>\n
      gradle build --profile<\/code><\/pre>\n
      You can find the HTML file inside the build\/reports\/profile<\/code> directory, as shown below.<\/p>\n
      \"directory<\/figure>\n
      If you run the HTML file, you can see the build details in the browser as shown below.<\/p>\n
      \"report<\/figure>\n
      What are the differences between Gradle and Maven?<\/h2>\n
      The key differences between Gradle and Maven are listed below:<\/p>\n
      <\/p>\n\n\n\n\n\n\n\n\n\n\n
      Gradle<\/td>\nMaven<\/td>\n<\/tr>\n
      Uses Groovy or Kotlin DSL based configuration file<\/td>\nUses XML based configuration file<\/td>\n<\/tr>\n
      It does not natively support caching<\/td>\nIt does not natively supports caching<\/td>\n<\/tr>\n
      Gradle build files are highly customizable and readable<\/td>\nMavens build files are less customizable and complex<\/td>\n<\/tr>\n
      Building project fater than Maven and only rebuilds new changes<\/td>\nBuild speed is slow, and rebuild the whole project if any changes are made<\/td>\n<\/tr>\n
      Supports multi-project builds natively<\/td>\nAlso supports multi-project builds but needs additional configurations, which are complex<\/td>\n<\/tr>\n
      The directory structure can be customized<\/td>\nFixed directory sturcture. For example, src\/main\/java.<\/td>\n<\/tr>\n
      Supports languages like Java, C\/C++, Groovy, etc\u2026<\/td>\nSupports languages like Java, Scala, C#, Ruby, etc\u2026<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
      <\/p>\n
      Conclusion<\/h2>\n
      In this guide, we have learned about the build tool Gradle, its configurations file, built a Java application using it, and additional important Gradle commands.<\/p>\n
      Not only that, we have also checked the application build by running the JAR file and accessing it on the web.<\/p>\n
      \n
      Ngu\u1ed3n:<\/strong> How to Build Java Application Using Gradle? \u2014 DevOpsCube<\/a><\/p>\n","protected":false},"excerpt":{"rendered":"
      Source: https:\/\/devopscube.com\/build-java-application-using-gradle\/<\/p>\n","protected":false},"author":1,"featured_media":557,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[1],"tags":[],"class_list":["post-556","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-devops"],"_links":{"self":[{"href":"https:\/\/blog.ngocha.biz\/index.php?rest_route=\/wp\/v2\/posts\/556","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/blog.ngocha.biz\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/blog.ngocha.biz\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/blog.ngocha.biz\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/blog.ngocha.biz\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=556"}],"version-history":[{"count":0,"href":"https:\/\/blog.ngocha.biz\/index.php?rest_route=\/wp\/v2\/posts\/556\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/blog.ngocha.biz\/index.php?rest_route=\/wp\/v2\/media\/557"}],"wp:attachment":[{"href":"https:\/\/blog.ngocha.biz\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=556"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/blog.ngocha.biz\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=556"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/blog.ngocha.biz\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=556"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}