Gradle කියන්නේ මොකක්ද? | Java, Android Projects වලට නියම SC Guide එකක්

කලින් කාලේ Software Project එකක් හදද්දි තිබ්බ ලොකුම headaches වලින් එකක් තමයි Project එක build කරන එක. Source code compile කරනවා, dependencies ටික manage කරනවා, test කරනවා, package කරනවා... අයියෝ, මේ වැඩේට කීයක් යනවද? ආසාවට වගේ මේ ඔක්කොම අතින් කරන්න ගියොත් දවස් ගාණක් යයි නේද? අන්න ඒ වගේ තැන්වලට තමයි build automation tools උදව්වට එන්නේ.

මේ Tools වලින් කරන්නේ අපේ Project එක හදන්න ඕන කරන ඔක්කොම වැඩ ටික automate කරන එක. එතකොට අපිට පුළුවන් coding වලට විතරක් අවධානය දෙන්න. අතින් ගහන වැඩ නැති කරනවා කියන්නේ වැඩේ ගොඩක් පහසු වෙනවා. අද අපි කතා කරන්න යන්නේ මේ වගේ Powerful Tool එකක් ගැන – ඒ තමයි Gradle.

ඔයාලා Java හෝ Android development කරනවා නම්, Gradle නම අහලා ඇති. Android Studio පාවිච්චි කරන ඕනම කෙනෙක් දන්නවා මේක කොච්චර වැදගත්ද කියලා. එහෙනම්, අපි බලමු Gradle කියන්නේ මොකක්ද, ඇයි මේක මේ තරම් ජනප්‍රිය වුණේ, සහ මේකෙන් අපේ වැඩ කොහොමද පහසු වෙන්නේ කියලා. එහෙනම් වැඩේට බහිමු.

Gradle කියන්නේ මොකක්ද?

සරලවම කිව්වොත්, Gradle කියන්නේ open-source build automation tool එකක්. මේක විශේෂයෙන්ම නිර්මාණය කරලා තියෙන්නේ software projects වල build process එක automate කරන්න. Code compile කරන එකේ ඉඳන්, testing, packaging, deployment වගේ දේවල් දක්වාම මේකෙන් automate කරන්න පුළුවන්. ඒ වගේම, මේක Java, Groovy, Scala, Kotlin වගේ JVM languages විතරක් නෙවෙයි, C++, Swift වගේ languages වලටත් support කරනවා. ඒ වගේම Android development වලට මේක අත්‍යවශ්‍ය tool එකක් වෙලා තියෙනවා.

අනිත් build tools වලට වඩා Gradle වෙනස් වෙන්නේ මේකේ flexibility එකයි performance එකයි නිසා. Maven වගේ tools වලට වඩා, Gradle අපිට වැඩි නිදහසක් දෙනවා අපේ build process එක customize කරන්න. ඒක කරන්නේ Groovy හෝ Kotlin DSL (Domain Specific Language) එකක් පාවිච්චි කරලා build scripts ලියන එකෙන්. XML configuration files වලට වඩා මේ script languages පාවිච්චි කරන එක programmers ලට ගොඩක් පහසුයි කියලයි කියන්නේ. Programming background එකක් තියෙන අයට මේකෙන් වැඩ කරන එක හරිම ලේසියි.

Gradle වල තියෙන තවත් විශේෂත්වයක් තමයි මේක incremental builds වලට support කරන එක. ඒ කියන්නේ, ඔයා Project එකේ පොඩි වෙනසක් කළාම, Gradle එක කලින් build එකේ ඉඳන් වෙනස් වුණ parts විතරක් අලුතින් build කරනවා. මේක නිසා build time එක ගොඩක් අඩු වෙනවා, විශේෂයෙන්ම ලොකු projects වලදී. හිතන්නකෝ, ලොකු Project එකක පොඩි bug fix එකකට ආයෙත් මුළු Project එකම build කරන්න ඕන වුණා නම් කොච්චර වෙලාවක් යයිද කියලා. Gradle එකෙන් ඒ ප්‍රශ්නේ නිරාකරණය කරනවා.

ඇයි අපි Gradle පාවිච්චි කරන්නේ?

Build automation tools අතරේ Gradle මේ තරම් ජනප්‍රිය වුණේ ඇයි කියලා අපි පොඩ්ඩක් බලමු. මේවා තමයි ප්‍රධාන හේතු:

• නම්‍යශීලී බව (Flexibility): Gradle වල build scripts ලියන්නේ Groovy හෝ Kotlin වලින්. මේක programmatically build process එක control කරන්න අපිට ලොකු නිදහසක් දෙනවා. Maven වල වගේ XML files වල configuration විතරක් නෙවෙයි, අපිට ඕන විදිහට custom tasks හදන්න, existing tasks modify කරන්න පුළුවන්. මේකෙන් Project එකේ විශේෂ අවශ්‍යතා වලට අනුව build එක හදන්න පුළුවන්කම ලැබෙනවා. ඔයාට unique build process එකක් තියෙනවා නම්, Gradle තමයි ඒකට හොඳම විසඳුම.
• කාර්ය සාධනය (Performance):
  • Incremental Builds: කලින් කිව්වා වගේ, Gradle එක වෙනස් වුණ components විතරක් build කරනවා. මේක විශාල projects වලදී build time එක ගොඩක් අඩු කරනවා.
  • Build Cache: Gradle එක කලින් build කරපු output එක cache කරලා තියාගන්නවා. ඒක නිසා, එකම module එක ආයෙත් build කරන්න ඕන වුණාම, cache එකෙන් result එක අරගෙන වේගයෙන් වැඩේ ඉවර කරන්න පුළුවන්. මේකෙන් disk space ටිකක් යනවා වුණත්, වේගය නම් ඉහළයි.
  • Parallel Execution: Gradle එකට පුළුවන් එකිනෙකට ස්වාධීන tasks එකම වෙලාවේ parallelly execute කරන්න. මේකත් multi-core processors තියෙන machines වල build time එක අඩු කරන්න උදව් වෙනවා.
• විශාල පරිමාණයට සහය (Scalability for Multi-Project Builds): ලොකු projects වල, modules ගොඩක් තියෙන projects වලදී Gradle ඉතා හොඳින් වැඩ කරනවා. Single root project එකක් යටතේ sub-projects ගොඩක් manage කරන්න පුළුවන්. Common configurations parent project එකේ තියලා, sub-projects වලට ඒවා extend කරන්න පුළුවන්. මේක Project structure එක organize කරගන්නත් ලොකු පහසුවක්.
• විශාල Plugin Ecosystem එකක් (Rich Plugin Ecosystem): Gradle වලට විවිධ plugins විශාල ප්‍රමාණයක් තියෙනවා. Java, Android, Spring Boot වගේ දේවල් වලට official plugins තියෙනවා වගේම, third-party plugins ගොඩකුත් තියෙනවා. මේවා පාවිච්චි කරලා අපිට build process එකට අමතර functionality එකතු කරන්න පුළුවන්. උදාහරණයක් විදිහට code quality checks, code coverage reports වගේ දේවල් integrate කරන්න පුළුවන්.
• IDE Integration: IntelliJ IDEA, Eclipse, Android Studio වගේ ප්‍රධාන IDEs ඔක්කොම Gradle වලට හොඳින් support කරනවා. මේක නිසා අපිට IDE එක ඇතුලෙන්ම build tasks run කරන්න, dependencies manage කරන්න පුළුවන්. IDE එකේ Gradle tool window එක හරහා tasks run කරන එක CLI එකෙන් run කරනවට වඩා පහසුයි.

Gradle වල ප්‍රධාන Concepts ටිකක්

Gradle පාවිච්චි කරනකොට අපිට නිතරම හම්බවෙන වැදගත් concepts ටිකක් ගැන දැන් අපි දැනගමු. මේ ටික තේරුම් ගත්තා නම් Gradle එක්ක වැඩ කරන එක හරිම ලේසියි.

• Plugins:Plugins කියන්නේ Gradle වලට අමතර functionality එකතු කරන packages. උදාහරණයක් විදිහට, java plugin එක අපේ project එක Java project එකක් විදිහට build කරන්න අවශ්‍ය tasks ටික automate කරනවා (compile, test, jar). application plugin එක command-line application එකක් run කරන්න අවශ්‍ය tasks ටික provide කරනවා. Android development වලදී com.android.application plugin එක අත්‍යවශ්‍යයි. Plugins පාවිච්චි කරන එකෙන් අපිට boilerplate code ලියන එක වළක්වා ගන්න පුළුවන්, මොකද standard functionalities ගොඩක් ඒවගෙන් provide කරනවා.
• Dependencies:Dependencies කියන්නේ අපේ project එකට අවශ්‍ය වෙන external libraries හෝ modules. මේවා සාමාන්‍යයෙන් Maven Central, JCenter වගේ public repositories වලින් ගන්න පුළුවන්. build.gradle file එකේ dependencies block එක ඇතුලත මේවා define කරනවා. උදාහරණයක් විදිහට, implementation 'org.springframework:spring-core:5.3.1' වගේ. Gradle එක විසින් මේ dependencies automate විදිහට download කරලා project එකට එකතු කරනවා. මේක Project එකේ build path එක manage කරන එක හරිම පහසු කරනවා.විවිධ dependency configurations තියෙනවා:
  • implementation: Compile time එකේදී සහ runtime එකේදී අවශ්‍ය dependencies. මේවා Project එකේ API එකට expose වෙන්නේ නැහැ.
  • api: Compile time එකේදී සහ runtime එකේදී අවශ්‍ය dependencies. මේවා Project එකේ API එකට expose වෙනවා.
  • testImplementation: Tests run කරන්න විතරක් අවශ්‍ය dependencies. Main application code එකට මේවා බලපාන්නේ නැහැ.
  • runtimeOnly: Runtime එකේදී විතරක් අවශ්‍ය dependencies. Compile time එකේදී අවශ්‍ය නැහැ.
  • compileOnly: Compile time එකේදී විතරක් අවශ්‍ය dependencies. Runtime එකේදී අවශ්‍ය නැහැ.
• Gradle Wrapper (gradlew):gradlew (Gradle Wrapper) කියන්නේ Gradle project එකක් run කරන්න recommend කරන method එක. මේකෙන් කරන්නේ, Project එක clone කරගන්න ඕනම කෙනෙක්ට, තමන්ගේ machine එකේ Gradle install කරලා නැති වුණත්, Project එක run කරන්න අවශ්‍ය Gradle version එක automate විදිහට download කරලා setup කරන එක. මේකෙන් "It works on my machine" වගේ ප්‍රශ්න අඩු කරගන්න පුළුවන්, මොකද Project එකට අදාළව නිවැරදි Gradle version එක හැමෝටම ලැබෙනවා. Project එකේ root directory එකේ gradlew (Linux/macOS) සහ gradlew.bat (Windows) වගේ files ටිකක් තියෙනවා. මේවා තමයි අපි සාමාන්‍යයෙන් Gradle commands run කරන්න පාවිච්චි කරන්නේ.

Tasks:Task එකක් කියන්නේ Gradle වල build process එකේ තියෙන වැඩ කොටසක්. උදාහරණයක් විදිහට, code compile කරන එක task එකක්, tests run කරන එක task එකක්, JAR file එකක් හදන එක තවත් task එකක්. අපිට custom tasks හදන්නත් පුළුවන්. උදාහරණයක් විදිහට, files copy කරන task එකක්, database migrations run කරන task එකක් වගේ දේවල්. Tasks එකිනෙකට dependencies තියෙන්න පුළුවන්. ඒ කියන්නේ, task එකක් run වෙන්න කලින් තව task එකක් run වෙන්න ඕනේ කියලා define කරන්න පුළුවන්.

gradle tasks       # Project එකේ available tasks ටික බලන්න
gradle build       # Project එක build කරන්න
gradle clean       # Build artifacts ටික clean කරන්න
gradle hello       # අපි හැදුව custom task එක run කරන්න
        

Build Script (build.gradle):මේක තමයි Gradle project එකක හදවත. අපේ build process එක define කරන logic එක තියෙන්නේ මේ file එකේ. මේක Groovy හෝ Kotlin DSL එකෙන් ලියන්න පුළුවන්. සාමාන්‍යයෙන් Project එකේ root directory එකේ build.gradle කියලා file එකක් තියෙනවා. Sub-projects වලට වෙනම build.gradle files තියෙන්නත් පුළුවන්. හැම file එකකම project එකේ behavior එක define කරනවා.

// build.gradle (Groovy DSL) - සරල Java Project එකක build.gradle file එකක්
plugins {
    id 'java' // Java plugin එක apply කරනවා
    id 'application' // Application plugin එක apply කරනවා, run task එකට
}

group 'com.example' // Group ID එක
version '1.0-SNAPSHOT' // Project version එක

repositories {
    mavenCentral() // Dependencies ගන්න පුළුවන් තැන (Maven Central Repository)
    // jcenter() // තවත් repository එකක්
}

dependencies {
    // Test dependencies - Tests run කරන්න විතරක් අවශ්‍ය ඒවා
    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.8.1'
    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.8.1'

    // Compile time dependency උදාහරණයක් - Project එක compile වෙන්න සහ run වෙන්න අවශ්‍යයි
    implementation 'com.google.guava:guava:31.0.1-jre' // Google Guava Library එක
}

// Test configuration
test {
    useJUnitPlatform()
}

// Application plugin එකේ main class එක define කරනවා
application {
    mainClass = 'com.example.App'
}

// Custom task එකක් හදන හැටි
tasks.register('hello') {
    doLast {
        println 'ආයුබෝවන්, ලංකාව! Gradle වැඩේ හරි!' // Console එකේ print වෙනවා
    }
}
        

සරල Gradle Project එකක් පටන් ගමු

හරි, දැන් අපි පොඩි Project එකක් හදලා බලමු. මේක Java command-line application එකක්. මේ steps ටික follow කරලා ඔයාලටත් ගෙදරදීම try කරලා බලන්න පුමළුවන්.

Project එක Run කරමු: Build වුණාට පස්සේ, application එක run කරන්න මේ command එක පාවිච්චි කරන්න:

./gradlew run
        

Output එකේ "ආයුබෝවන් ලෝකෙට, Gradle එක්ක!" සහ "අපි දැන් Build Automation දන්නවා, නේද?" කියලා print වෙන්න ඕනේ. එහෙනම් වැඩේ සාර්ථකයි!

Project එක Build කරමු: Terminal එකේ Project root directory එකේ ඉඳන් මේ command එක run කරන්න:

./gradlew build
        

Windows නම් gradlew build කියලා run කරන්න පුළුවන්. මේකෙන් code එක compile වෙලා, tests run වෙලා, JAR file එකක් build/libs directory එක ඇතුලට හැදෙයි. Build එක සාර්ථක වුණා කියලා message එකක් එයි.

App.java File එක බලමු: src/main/java/com/example/App.java file එක open කරලා බලන්න. ඒකේ Hello World program එකක් ඇති. අපි පොඩ්ඩක් වෙනස් කරමු අපේ Lankan style එකට. මේ වගේ code එකක් දාමු:

// src/main/java/com/example/App.java
package com.example;

public class App {
    public static void main(String[] args) {
        System.out.println("ආයුබෝවන් ලෝකෙට, Gradle එක්ක!");
        System.out.println("අපි දැන් Build Automation දන්නවා, නේද?");
    }
}
        

Project එකක් හදමු: Terminal එක Open කරලා, ඔයාගේ Project එක හදන්න ඕන directory එකට ගිහින් මේ command එක run කරන්න:

gradle init
        

මේක run කරාම Project type එක, language එක, build script DSL එක වගේ දේවල් අහයි. අපි මෙතන application, Java, Groovy වගේ දේවල් select කරමු. Command line එකේ instructions ටික හරියට follow කරන්න. Project Name එක "my-app" වගේ එකක් දෙන්න පුgළුවන්.ඊට පස්සේ Project Structure එක මේ වගේ වෙයි:

my-app/
├── .gradle/ # Gradle caches and other internal files
├── build/   # Build outputs (compiled classes, jars, reports)
├── gradle/
│   └── wrapper/
│       ├── gradle-wrapper.jar
│       └── gradle-wrapper.properties
├── gradlew    # Gradle Wrapper script (Linux/macOS)
├── gradlew.bat # Gradle Wrapper script (Windows)
├── settings.gradle # Multi-project builds configure කරන file එක
├── build.gradle    # Main build script
└── src/
    ├── main/
    │   ├── java/
    │   │   └── com/
    │   │       └── example/
    │   │           └── App.java # Your application's main Java file
    │   └── resources/ # Application resources (e.g., config files)
    └── test/
        ├── java/
        │   └── com/
        │       └── example/
        │           └── AppTest.java # Unit tests for your application
        └── resources/
        

වැදගත් Commands ටිකකුයි Tips ටිකකුයි

Gradle පාවිච්චි කරනකොට ඔයාලට ගොඩක් වැදගත් වෙන Commands ටිකක් සහ Tips ටිකක් මෙන්න. මේවා මතක තියාගත්තොත් ඔයාලගේ දවස පහසු වෙයි.

• ./gradlew tasks: මේකෙන් ඔයාලගේ Project එකේ available tasks ඔක්කොම බලන්න පුළුවන්. Group කරලා පෙන්නන නිසා හොයාගන්න ලේසියි. නවක අයට මේක හරිම ප්‍රයෝජනවත් command එකක්.
• ./gradlew clean: Build process එකෙන් generate වුණු artifacts (compiled classes, JAR files) ඔක්කොම clean කරන්න මේක පාවිච්චි කරනවා. අලුතින් build කරන්න කලින් මේක run කරන එක හොඳ පුරුද්දක්, විශේෂයෙන්ම build errors එන වෙලාවට.
• ./gradlew test: Project එකේ තියෙන tests run කරන්න. Test failures එනවා නම්, ඒකට අදාළ reports build/reports/tests directory එකේ තියෙනවා.
• ./gradlew dependencies: Project එකේ dependency tree එක බලන්න. මොන dependency එක කොහෙද තියෙන්නේ, මොන versions ද use කරන්නේ කියලා මේකෙන් පැහැදිලිව බලාගන්න පුළුවන්. Conflicts එහෙම තියෙනවා නම් මේකෙන් identify කරන්න ලේසියි.
• ./gradlew build --info හෝ ./gradlew build --debug: Build process එක ගැන වැඩි විස්තර දැනගන්න අවශ්‍ය නම් මේ flags පාවිච්චි කරන්න පුළුවන්. Troubleshoot කරනකොට ගොඩක් ප්‍රයෝජනවත්, මොකද detailed logs පෙන්නනවා.
• Gradle Wrapper පාවිච්චි කරන්න: හැම වෙලාවෙම gradlew (හෝ gradlew.bat) පාවිච්චි කරන්න. ඒකෙන් ඔයාලගේ Project එකට අවශ්‍ය නිවැරදි Gradle version එක use කරනවා කියලා sure කරගන්න පුළුවන්. එතකොට "මගේ machine එකේ වැඩ කරනවා, ඔයාගේ එකේ වැඩ කරන්නේ නැහැ" වගේ ප්‍රශ්න එන්නේ නැහැ.
• Build Cache එක enable කරන්න: gradle.properties file එකේ org.gradle.caching=true කියලා දාන්න. මේක build time එක ගොඩක් අඩු කරන්න උදව් වෙනවා. විශේෂයෙන්ම large projects වලදී මේක අත්‍යවශ්‍යයි.
• IDE එකත් එක්ක වැඩ කරන්න: IntelliJ IDEA, Android Studio වගේ IDEs වලට Gradle වලට හොඳින් support කරනවා. IDE එකේ Build/Gradle window එක පාවිච්චි කරලා tasks run කරන්න, dependencies manage කරන්න පුරුදු වෙන්න. මේක CLI එකට වඩා පහසුයි, විශේෂයෙන්ම graphic interface එකක් පාවිච්චි කරන්න කැමති අයට.

අවසන් වශයෙන්

Gradle කියන්නේ modern software development වලට නැතුවම බැරි Tool එකක්. විශේෂයෙන්ම Java සහ Android ecosystems වලදී මේකේ වටිනාකම කියලා නිම කරන්න බැහැ. මේකේ flexibility එක, performance එක, සහ විශාල plugin ecosystem එක නිසා ඕනම Project එකක build process එක automate කරන්න මේක කදිම විසඳුමක්. අද අපි කතා කරපු Concepts ටික, Commands ටික ඔයාලට Gradle ගැන හොඳ අවබෝධයක් ගන්න උදව් වෙන්න ඇති කියලා හිතනවා.

දැන් ඉතින් පරණ build headaches අමතක කරලා, Gradle එක්ක ඔයාලගේ Projects වලට අලුත් ජීවයක් දෙන්න කාලය හරි. ඔයාලත් මේක පාවිච්චි කරලා බලන්න. මොනවහරි ප්‍රශ්න තියෙනවා නම්, පහලින් comment එකක් දාන්න. ඔයාලා Gradle පාවිච්චි කරලා තියෙනවද? මොනවද ඔයාලගේ අත්දැකීම්? අපි කතා කරමු!

ඊළඟ ලිපියෙන් හම්බවෙමු! සැමට සුබ දවසක්!