Java වල Gradle Project Structure - build.gradle, settings.gradle | Sinhala Dev Guide

කොහොමද යාලුවනේ! අද මම ඔයාලා එක්ක කතා කරන්න යන්නේ Java Software Engineering වලට නැතුවම බැරි, ගොඩක් වැදගත් මාතෘකාවක් ගැන – ඒ තමයි Gradle Project Structure එක. ඔයාලා අලුතින් Java project එකක් පටන් ගන්නකොට හරි, existing project එකක් බලනකොට හරි මේ Gradle කියන එක අනිවාර්යයෙන්ම දකින්න ඇති. සමහරවිට "මේ මොනවද මචං මේ files ටික? මේක කොහොමද වැඩ කරන්නේ?" කියලා හිතාගන්න බැරුව ඉන්නත් ඇති. විශේෂයෙන්ම, build.gradle සහ settings.gradle files දෙකයි, ඒ වටේ තියෙන Project Layout එකයි ගැන හරියටම අවබෝධයක් නැත්නම්, project එකක් build කරන එක, dependencies manage කරන එක ටිකක් වදයක් වෙන්න පුළුවන්. ඒත් බයවෙන්න එපා, අද අපි මේ හැමදේම සිංහලෙන්, අපේ විදිහට, සරලව තේරුම් ගමු.

අද කතා කරන දේවල් එක්ක, ඔයාලට පුළුවන් වෙයි Gradle project එකක් හරියටම setup කරගන්න, dependencies හසුරුවන්න, custom tasks ලියන්න, ඒ වගේම ඕනෑම Gradle project එකක structure එක තේරුම් අරන් වැඩ කරන්න. එහෙනම් අපි වැඩේට බහිමු!

මොකක්ද මේ Gradle?

හරි, මුලින්ම බලමු මොකක්ද මේ Gradle කියන්නේ කියලා. සරලවම කිව්වොත්, Gradle කියන්නේ Build Automation Tool එකක්. Build Automation Tool එකක් කිව්වහම මොකක්ද අදහස් වෙන්නේ? අපි Java project එකක් හදනකොට, ඒක compile කරන්න ඕනේ, tests run කරන්න ඕනේ, ඒ files ටික එකතු කරලා JAR (Java Archive) එකක් හරි WAR (Web Application Archive) එකක් හරි හදන්න ඕනේ, සමහරවිට dependencies (ඒ කියන්නේ අපේ project එකට ඕන වෙන අනිත් libraries) download කරගන්න ඕනේ. මේ හැමදේම අතින් කරන්න ගියොත් හරිම අමාරුයි, වෙලාව යනවා, වැරදි වෙන්නත් පුළුවන්.

Gradle වගේ tool එකකින් වෙන්නේ, මේ හැමදේම automate කරන එක. අපි එයාට කියනවා මොනවද කරන්න ඕනේ කියලා, එයා ඒ වැඩේ හරියට කරනවා. මේක Maven, Ant වගේ tools වලටත් සමානයි. හැබැයි Gradle වල තියෙන විශේෂත්වය තමයි Groovy (or Kotlin DSL) කියන powerful scripting language එක පාවිච්චි කරලා build scripts ලියන්න පුළුවන් වීම. ඒ නිසා අපිට හරිම Flexible විදිහට, ඕන කරන විදිහට build process එක customize කරගන්න පුළුවන්. ඒ වගේම Gradle ගොඩක් වේගවත්, විශාල projects manage කරන්නත් හරිම පහසුයි.

Core Files ටික දැනගමු: build.gradle සහ settings.gradle

Gradle project එකක් පටන් ගත්තම ඔයාලට අනිවාර්යයෙන්ම දකින්න ලැබෙන files දෙකක් තමයි build.gradle සහ settings.gradle. මේ දෙක තමයි Gradle project එකක හදවත වගේ වැඩ කරන්නේ. අපි එකින් එක බලමු මේවායේ වැඩ මොනවද කියලා.

build.gradle – Project එකේ හැමදේම

build.gradle කියන්නේ ඔයාගේ project එකේ build logic එක define කරන ප්‍රධානම file එක. සරලව කිව්වොත්, මේ project එක build වෙන්න ඕනේ කොහොමද, ඒකට මොන dependencies ද ඕනේ, මොන tasks ද run වෙන්න ඕනේ කියන හැම විස්තරයක්ම තියෙන්නේ මේ file එකේ. මේක Groovy (or Kotlin) language එකෙන් ලියපු script එකක්.

සාමාන්‍ය Java project එකක build.gradle file එකක් මෙන්න මේ වගේ වෙන්න පුළුවන්:

plugins {
    id 'java' // Java plugin එක apply කරනවා
    id 'application' // Executable JAR එකක් හදන්න
}

group 'com.srilankadevs' // Project එකේ Group ID එක
version '1.0-SNAPSHOT' // Project එකේ Version එක

repositories {
    mavenCentral() // Dependencies ගන්න Maven Central repository එක භාවිතා කරනවා
}

dependencies {
    // Test dependencies
    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.8.1'
    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.8.1'

    // Compile-time dependencies (උදා: Spring Boot Web dependency)
    implementation 'org.springframework.boot:spring-boot-starter-web:2.6.2'
}

test {
    useJUnitPlatform() // JUnit 5 tests run කරන්න
}

application {
    mainClass = 'com.srilankadevs.MyApplication' // Main class එක specify කරනවා
}

// Custom task එකක්
task helloGradle {
    doLast {
        println 'Hello from Sinhala Coders!'
    }
}

මේ code එකේ තියෙන වැදගත් කොටස් ටික පැහැදිලි කරමු:

• plugins {}: මේකෙන් අපි project එකට අවශ්‍ය Gradle plugins apply කරනවා. java plugin එකෙන් Java source code compile කරන්න, tests run කරන්න වගේ දේවල් වලට අවශ්‍ය tasks සහ conventions සපයනවා. application plugin එකෙන් executable JAR file එකක් හදන්න සහ main class එක specify කරන්න පුළුවන් වෙනවා.
• group සහ version: මේවා තමයි project එකේ identifying details. අපි project එක publish කරනකොට මේවා ගොඩක් වැදගත් වෙනවා.
• repositories {}: Dependencies download කරගන්න ඕන කොහෙන්ද කියලා කියන්නේ මේකෙන්. mavenCentral() කියන්නේ standard repository එකක්, ගොඩක් open-source libraries මෙතනින් ගන්න පුළුවන්.
• dependencies {}: මෙතන තමයි අපේ project එකට ඕන වෙන libraries specify කරන්නේ.
  • implementation: Compile-time සහ Runtime දෙකටම අවශ්‍ය dependencies. සාමාන්‍යයෙන් අපේ code එකේ කෙලින්ම පාවිච්චි කරන libraries.
  • testImplementation: Tests run කරන්න විතරක් අවශ්‍ය dependencies. අපේ main code එකට මේවායේ බලපෑමක් නෑ.
  • testRuntimeOnly: Test run කරන වෙලාවට විතරක් අවශ්‍ය dependencies.
• test {}: Test execution related configurations මෙතන දානවා. useJUnitPlatform() කියන්නේ JUnit 5 tests run කරන්න අවශ්‍ය setting එක.
• application {}: application plugin එක apply කරාම, executable JAR එකක් හැදෙනකොට run වෙන්න ඕන main class එක specify කරන්න පුළුවන්.
• Custom Task: task helloGradle {} වගේ ඔයාට ඔයාගේම tasks හදාගන්න පුළුවන්. doLast block එක ඇතුලේ තමයි task එක run වෙනකොට වෙන්න ඕන දේවල් ලියන්නේ.

settings.gradle – Multi-Project Builds වලට

settings.gradle file එකේ ප්‍රධානම කාර්යය තමයි Gradle build එකකට අදාළ Subprojects මොනවද කියලා define කරන එක. මේක සාමාන්‍යයෙන් තියෙන්නේ project එකේ root directory එකේ. ඔයා Single-project build එකක් කරනවා නම්, මේ file එකේ වැඩි ලොකු දේවල් දකින්න ලැබෙන්නේ නැති වෙන්න පුළුවන්, සමහරවිට rootProject.name එක විතරක් තියේවි. හැබැයි, ඔයාගේ project එක modules කිහිපයකට (subprojects) බෙදලා තියෙනවා නම් (උදා: core module, web module, service module), settings.gradle file එක ගොඩක් වැදගත් වෙනවා.

Multi-project build එකකදී settings.gradle file එක මෙන්න මේ වගේ වෙන්න පුළුවන්:

rootProject.name = 'MyMultiModuleProject'

include 'core-module', 'web-module', 'service-module' // Subprojects ටික define කරනවා

මේකේ include කියන method එකෙන් අපි Gradle build එකට අදාළ subprojects මොනවද කියලා specify කරනවා. Gradle මේ files ටික මේ modules වලට අදාළ directories වල හොයනවා. මේ හැම subproject එකකටම තමන්ගේම build.gradle file එකක් තියෙන්න පුළුවන්. ඒ වගේම root project එකටත් build.gradle එකක් තියෙන්න පුළුවන්, ඒකෙන් common configurations define කරන්න පුළුවන්.

Gradle Standard Project Layout එක

Gradle project එකක් හදනකොට, Gradle එකටම ආවේණික standard directory structure එකක් තියෙනවා. මේ structure එක follow කරන එක ගොඩක් වැදගත්, මොකද Gradle එක automatically මේ folders වල source code, resources, tests වගේ දේවල් හොයාගන්නවා. මේක "convention over configuration" කියන concept එකට අදාළයි. ඒ කියන්නේ, අපි standard convention එක follow කරනවා නම්, අපිට build.gradle file එකේ අනවශ්‍ය විදිහට වැඩිපුර දේවල් configure කරන්න ඕන වෙන්නේ නෑ.

සාමාන්‍ය Gradle Java project එකක structure එක මෙන්න මේ වගේ වෙයි:

.
├── build.gradle
├── settings.gradle
├── gradlew
├── gradlew.bat
├── src
│   ├── main
│   │   ├── java
│   │   │   └── com
│   │   │       └── srilankadevs
│   │   │           └── MyApplication.java
│   │   └── resources
│   │       └── application.properties
│   └── test
│       ├── java
│       │   └── com
│       │       └── srilankadevs
│       │           └── MyApplicationTest.java
│       └── resources
│           └── testdata.json
└── build/ # මේක Gradle build එකෙන් generate වෙන output එක

මේ structure එකේ වැදගත් කොටස් ටික බලමු:

• build.gradle: Project එකේ build script එක (මේ ගැන අපි උඩින් කතා කරා).
• settings.gradle: Multi-project build එකක් නම් subprojects identify කරන්න (මේ ගැනත් උඩින් කතා කරා).
• gradlew / gradlew.bat: මේවා Gradle Wrapper scripts. මේවා පාවිච්චි කරලා අපිට Gradle install කරන්නේ නැතුව වුණත් project එක build කරන්න පුළුවන්. මොකද මේවා project එකටම අදාළ Gradle version එක download කරගෙන build process එක run කරනවා. මේක "Build Environment consistency" එකට ගොඩක් වැදගත්.
• src/: මේක තමයි අපේ source code එක තියෙන ප්‍රධානම folder එක.
  • src/main/: Production code එක සහ resources තියෙන්නේ මෙතන.
    • src/main/java/: අපේ Java source code files (.java) තියෙන්නේ මේ folder එකේ. Package structure එක මේක ඇතුලේ හැදෙනවා (com/srilankadevs/MyApplication.java වගේ).
    • src/main/resources/: Application එකට අවශ්‍ය configuration files (application.properties, log4j.xml වගේ), static files (HTML, CSS, JS) වගේ දේවල් තියෙන්නේ මෙතන. මේවා compile වෙන්නේ නෑ, direct copy වෙනවා.
  • src/test/: Tests related code එක සහ resources තියෙන්නේ මෙතන.
    • src/test/java/: Unit tests සහ Integration tests වල Java source code මෙතන තියෙනවා.
    • src/test/resources/: Tests වලට විතරක් අවශ්‍ය files (test data, mock configurations වගේ) තියෙන්නේ මෙතන.
• build/: මේ folder එක Gradle build එක run වෙනකොට automatically generate වෙනවා. Compile කරපු classes, JAR files, test reports, build artifacts වගේ හැම output එකක්ම මේ folder එක ඇතුලට තමයි එන්නේ. මේ folder එක Git වගේ Version Control system වලට commit කරන්නේ නෑ, .gitignore එකේ add කරනවා.

Tips and Tricks for Sri Lankan Devs

හරි, දැන් ඔයාලට Gradle project structure එක ගැන මූලික අවබෝධයක් ඇති. තව ටිකක් practical tips ටිකක් බලමු. මොකද අපි වැඩ කරනකොට මේවා ගොඩක් වැදගත් වෙනවා:

1. අලුත් Project එකක් පටන් ගමු: Intellij IDEA වගේ IDE එකක "New Project" එකක් හදනකොට Gradle archetype එකක් තෝරගන්න පුළුවන්. එතකොට standard structure එක automatically හැදෙනවා. නැත්නම් command line එකෙන් වුණත් gradle init කියලා ටයිප් කරලා අලුත් project එකක් හදාගන්න පුළුවන්. ඒකෙන් ඔයාට language, build script DSL (Groovy/Kotlin) වගේ දේවල් select කරන්නත් දෙනවා.
2. Dependencies හොයමු: ඔයාට ඕන කරන library එකක dependency එකක් හොයාගන්න ඕන නම්, Maven Central Repository (https://mvnrepository.com/) එකට ගිහින් බලන්න. එතන ඔයාට Maven, Gradle දෙකටම අදාළ dependency snippets හොයාගන්න පුළුවන්.
3. Task Run කරමු: Terminal එකේදී ඔයාගේ project root directory එකට ගිහින් ./gradlew build (Linux/macOS) හෝ gradlew build (Windows) කියලා ටයිප් කරලා project එක build කරන්න පුළුවන්. ./gradlew clean එකෙන් build folder එක delete කරනවා. ./gradlew tasks කියලා ගහලා ඔයාට project එකේ තියෙන හැම task එකක්ම බලන්න පුළුවන්.
4. Debug කරමු: Gradle build එකක් fail වෙනකොට, ./gradlew build --stacktrace හෝ ./gradlew build --debug වගේ commands වලින් වැඩිපුර information අරන් issue එක solve කරගන්න පුළුවන්.
5. Multi-Project Build එකක්ද?: ඔයාගේ project එක කාලයත් එක්ක ලොකු වෙනකොට modules කිහිපයකට කැඩෙන්න පුළුවන්. ඒ වෙලාවට settings.gradle file එක හරියට maintain කරන එක ගොඩක් වැදගත්. සාමාන්‍යයෙන් common dependencies root level build.gradle එකේ define කරලා, module specific dependencies අදාළ subproject build.gradle file එකේ දානවා.

ඉතින් යාලුවනේ, අද අපි කතා කළා Java වල Gradle Project Structure එක ගැන. build.gradle file එකේ තියෙන වැදගත්කම, settings.gradle file එක multi-project builds වලට කොච්චර වටිනවද කියන එක, ඒ වගේම Gradle standard project layout එක මොකක්ද කියන එක ඔයාලට දැන් පැහැදිලි ඇති කියලා මම හිතනවා. මේවා හරියට තේරුම් ගත්තා නම්, ඕනෑම Gradle project එකක වැඩ කරන එක ඔයාලට තවත් ලේසි වෙයි.

මේ concepts ටික ඔයාලගේම project එකකට apply කරලා බලන්න. පොඩි demo project එකක් හදලා build.gradle එක modify කරලා බලන්න, dependencies add කරලා බලන්න, custom tasks හදලා run කරලා බලන්න. එතකොට තමයි මේවා ඔලුවට හරියටම යන්නේ.

මේ ලිපිය ගැන ඔයාලගේ අදහස්, ප්‍රශ්න පහළින් comment කරන්න. ඔයාලට මේ වගේ තවත් මොන වගේ topics ගැනද දැනගන්න ඕනේ කියලත් කියන්න. එහෙනම් තවත් අලුත් ලිපියකින් හමුවෙමු, හැමෝටම ජය වේවා! 🇱🇰💻