Gradle Dependencies & Plugins: ඔබගේ Project එක පහසුවෙන් ගොඩනගමු! SC Dev Guide

කට්ටියට කොහොමද? අපේ කෝඩින් ලෝකෙට සාදරයෙන් පිළිගන්නවා!

අද අපි කතා කරන්න යන්නේ අපේ Software Engineering වලදී, විශේෂයෙන්ම Java සහ Android development කරන අයට නැතුවම බැරි මාතෘකාවක් ගැන. ඒ තමයි Gradle Dependencies සහ Plugins.

දැන් Project එකක් හදනකොට පොඩිම Project එකකට වුණත් external libraries, frameworks, සහ tools ගොඩක් ඕන වෙනවා. ඒ හැමදේම manually manage කරන එක හිතාගන්නවත් බැරි තරම් අමාරු වැඩක්. ඕතනට තමයි Gradle වගේ Build Automation tools අපිට උදව් වෙන්නේ.

Gradle කියන්නේ අද ලෝකේ ගොඩක් දෙනෙක් use කරන powerful tool එකක්. ඒකෙන් පුළුවන් අපේ Project එක build කරන්න, test කරන්න, deploy කරන්න වගේ ගොඩක් දේවල් automate කරන්න. මේ හැමදේටම හදවත වගේ වැඩ කරන්නේ මේ Dependencies සහ Plugins තමයි. ඉතින්, අපි බලමු මේ දෙක මොනවද, ඒවා අපේ Project එකකට කොච්චර වැදගත්ද කියලා.

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

සරලවම කිව්වොත්, Gradle කියන්නේ Build Automation System එකක්. ඒකෙන් පුළුවන් අපේ Software Project එකක් හදන, compile කරන, package කරන, test කරන සහ deploy කරන process එක automate කරන්න. මේක Maven, Ant වගේ Tools වලට වඩා ගොඩක් flexible සහ powerful. ඒ වගේම, මේක Groovy සහ Kotlin DSL (Domain Specific Language) support කරන නිසා build scripts ලියන එක ගොඩක් පහසුයි.

හිතන්න, ඔයාලා Project එකක් කරනවා. ඒකේ source code files ගොඩක් තියෙනවා, external libraries ගොඩක් ඕන වෙනවා. මේ හැමදේම හරි විදියට එකතු කරලා, compile කරලා, run කරන්න පුළුවන් executable file එකක් හදන එක තමයි build process එකෙන් කරන්නේ. Gradle මේ මුළු process එකම automate කරලා දෙනවා. ඒ නිසා අපිට code කරන එකට විතරක් focus කරන්න පුළුවන්.

Gradle වල ප්‍රධාන වාසි කිහිපයක් තමයි:

• Performance: Incremental builds සහ build cache වගේ දේවල් නිසා build process එක ගොඩක් වේගවත්.
• Flexibility: Groovy සහ Kotlin DSL නිසා build logic ලියන්න ගොඩක් options තියෙනවා.
• Plugins: විවිධ functionalities එකතු කරන්න පුළුවන් plugins ගොඩක් තියෙනවා (Java, Android, Spring Boot වගේ).
• Dependency Management: Dependencies manage කරන එක ගොඩක් පහසුයි.

Dependencies කියන්නේ මොනවද?

දැන් අපි Project එකක් හදනකොට මුල ඉඳන්ම හැමදේම ලියන්නේ නැහැ. උදාහරණයක් විදියට, database එකක් manage කරන්න, web application එකක් හදන්න, user authentication කරන්න වගේ දේවල් වලට අපි අලුතින් code ලියන්නේ නැහැ. ඒ වෙනුවට, අනිත් අය හදලා තියෙන Libraries, Frameworks, සහ Modules අපි අපේ Project එකට එකතු කරගන්නවා. මේවට තමයි Dependencies කියලා කියන්නේ.

Dependencies වලින් වෙන්නේ අපේ Project එකේ සංකීර්ණතාවය අඩු කරන එක සහ development process එක වේගවත් කරන එක. හිතන්න, අපි Spring Boot Project එකක් හදනවා නම්, database එකක් manage කරන්න Spring Data JPA, web application එකක් හදන්න Spring Web වගේ Dependencies ඕන වෙනවා. මේවා නැතුව Project එකක් හදන්න බැහැ.

Gradle වල dependencies define කරන්නේ build.gradle file එකේ dependencies block එක ඇතුළේ. මේකට කලින් අපි dependencies download කරගන්න තැන් define කරන්න ඕන. ඒවට Repositories කියනවා. අපි ප්‍රධාන වශයෙන් use කරන්නේ Maven Central වගේ public repositories තමයි.

Dependency එකතු කරන හැටි:

repositories {
    mavenCentral()
    // jcenter() is deprecated, so generally avoid using it now
    // google()
}

dependencies {
    // Implementation dependency for a web application
    implementation 'org.springframework.boot:spring-boot-starter-web:2.7.5'

    // Test dependency for unit testing
    testImplementation 'org.springframework.boot:spring-boot-starter-test'

    // Compile-only dependency (e.g., for annotations, not included in final artifact)
    compileOnly 'org.projectlombok:lombok:1.18.24'

    // Runtime-only dependency (only needed at runtime, not compile time)
    runtimeOnly 'com.h2database:h2'

    // For Android projects, you might see this
    // implementation 'androidx.appcompat:appcompat:1.6.1'
}

මේ code එකේ තියෙන විදියට, dependency එකක් define කරද්දි අපි ප්‍රධාන වශයෙන් කොටස් තුනක් දෙනවා: Group ID, Artifact ID, සහ Version එක.

• Group ID (e.g., org.springframework.boot): Library එක අයිති සංවිධානය හෝ Project එක.
• Artifact ID (e.g., spring-boot-starter-web): Library එකේ නම.
• Version (e.g., 2.7.5): Library එකේ version එක.

ප්‍රධාන Dependency Configuration Types:

• implementation: මේක තමයි බහුලවම භාවිතා වන dependency type එක. මේක compile-time සහ runtime දෙකටම අවශ්‍යයි. Project එකේ code එකට මේ dependency එකේ class files access කරන්න පුළුවන්.
• api: මේකත් implementation වගේමයි, හැබැයි මේ dependency එකේ classes, current module එක මත dependent වෙන වෙන module වලටත් expose කරනවා. Library එකක් develop කරනකොට මේක වැදගත්.
• compileOnly: මේ dependency එක compile time එකේදී විතරයි අවශ්‍ය වෙන්නේ. Final artifact (JAR/WAR) එකට මේක include වෙන්නේ නැහැ. උදාහරණයක් විදියට Lombok වගේ libraries මේකට අයිතියි.
• runtimeOnly: මේ dependency එක runtime එකේදී විතරයි අවශ්‍ය වෙන්නේ. Compile time එකේදී මේක අවශ්‍ය නැහැ. Database drivers (e.g., H2, MySQL Connector) මේකට හොඳ උදාහරණ.
• testImplementation: මේක Unit testing සහ Integration testing වලදී විතරක් අවශ්‍ය වෙන dependencies වලට භාවිතා කරනවා. උදාහරණයක් විදියට JUnit, Mockito, Spring Boot Test වගේ.
• androidTestImplementation (Android Projects වලදී): Android instrumented tests වලට අවශ්‍ය dependencies වලට මේක භාවිතා කරනවා.

Plugins කියන්නේ මොනවද?

Gradle වල Plugins කියන්නේ Gradle වල core functionality එක extend කරන packages. සරලව කිව්වොත්, මේවා Gradle වලට අලුත් features සහ capabilities එකතු කරනවා. උදාහරණයක් විදියට, Java Project එකක් compile කරන්න, run කරන්න, test කරන්න අවශ්‍ය tasks set එකක් Gradle වලට එන්නේ Java Plugin එක apply කරාමයි.

අපි Project එකක් හදනකොට අපිට අවශ්‍ය විවිධ build tasks define කරන්න පුළුවන්. හැබැයි, common tasks (e.g., Java code compile කරන එක, JAR file එකක් හදන එක) හැම Project එකකටම අතින් ලියන්න ගියොත් වැඩේ එපා වෙනවා. Plugins වලින් කරන්නේ මේ common tasks bundle කරලා අපිට පහසුවෙන් use කරන්න දෙන එක. ඒ වගේම plugins වලට dependencies define කරන්න, new dependency configurations introduce කරන්න, සහ Project එකේ structure එකට බලපෑම් කරන්නත් පුළුවන්.

Plugin එකක් apply කරන හැටි:

අපි build.gradle file එකේ plugins block එක ඇතුළේ plugin එකක් apply කරනවා. මේක තමයි නවීන සහ recommend කරන ක්‍රමය. කලින් apply plugin: 'java' වගේ විදියටත් apply කලා, හැබැයි දැන් ඒක ඒ තරම් recommend කරන්නේ නැහැ.

plugins {
    id 'java' // Apply the standard Java plugin
    id 'org.springframework.boot' version '2.7.5' // Apply Spring Boot plugin with a specific version
    id 'io.spring.dependency-management' version '1.0.15.RELEASE' // Plugin for managing Spring Boot dependencies
    
    // For Android projects:
    // id 'com.android.application' version '7.4.2'
    // id 'org.jetbrains.kotlin.android' version '1.8.0'
}

මේ උදාහරණයේ තියෙන විදියට:

• id 'java': මේකෙන් standard Java plugin එක apply වෙනවා. මේක apply වුණාට පස්සේ තමයි අපිට javaCompile, jar, test වගේ tasks භාවිතා කරන්න පුළුවන් වෙන්නේ.
• id 'org.springframework.boot' version '2.7.5': මේකෙන් Spring Boot Project එකකට අවශ්‍ය functionality එකතු වෙනවා. උදාහරණයක් විදියට, executable JAR file එකක් හදන එක වගේ දේවල් මේකෙන් provide කරනවා.
• id 'io.spring.dependency-management' version '1.0.15.RELEASE': මේක Spring Boot Project වලදී dependency versions manage කරන්න භාවිතා කරන වැදගත් plugin එකක්. මේකෙන් පුළුවන් Spring Boot ecosystem එකේ dependencies වල compatibility එක ensure කරන්න.

Dependencies සහ Plugins එකට වැඩකරන හැටි

Plugins සහ Dependencies කියන්නේ එකිනෙකට සම්බන්ධ දේවල්. ගොඩක් වෙලාවට plugins තමයි අපිට අලුත් dependency configurations හඳුන්වා දෙන්නේ. උදාහරණයක් විදියට:

• ඔබ Java Plugin එක apply කරාම තමයි implementation, compileOnly, testImplementation වගේ dependency configurations enable වෙන්නේ.
• ඔබ Android Application Plugin එක apply කරාම තමයි Android Project එකකට අදාළ implementation, debugImplementation, androidTestImplementation වගේ configuration එන්නේ.

මේ නිසා, නිවැරදි plugin එක apply කිරීම, ඔබේ Project එකට අවශ්‍ය Dependencies නිවැරදිව manage කිරීමට පදනම සපයනවා.

Dependency Conflicts සහ ඒවා විසඳන හැටි:

ප්‍රධාන ගැටලුවක් තමයි Dependency Conflicts. මේක වෙන්නේ එකම Library එකේ different versions දෙකක් Project එකේ තියෙනකොට. උදාහරණයක් විදියට, Project එකේ dependency A එක, dependency C version 1.0 මත රඳා පවතිනවා. හැබැයි Project එකේ dependency B එක, dependency C version 2.0 මත රඳා පවතිනවා. මේ වගේ වෙලාවකදී Gradle වලට තීරණය කරන්න අමාරුයි මොන version එකද use කරන්නේ කියලා. මේකෙන් build failures හෝ runtime errors වෙන්න පුළුවන්.

මේ වගේ අවස්ථාවලදී අපිට resolutionStrategy භාවිතා කරන්න පුළුවන්. මේකෙන් පුළුවන් Gradle වලට specific version එකක් use කරන්න කියන්න.

configurations.all {
    resolutionStrategy {
        // Force a specific version for a conflicting dependency
        force 'com.fasterxml.jackson.core:jackson-databind:2.13.4'

        // Or exclude a transitive dependency that causes conflict
        // exclude group: 'org.slf4j', module: 'slf4j-log4j12'
    }
}

තවත් වැදගත් දෙයක් තමයි Transitive Dependencies. අපිට අවශ්‍ය library එකක් add කරාම, ඒ library එකටත් තව dependencies ගොඩක් තියෙන්න පුළුවන්. ඒ dependencies වලට තමයි transitive dependencies කියන්නේ. මේවා හැම එකක්ම Gradle automatically download කරනවා. සමහර වෙලාවට මේ transitive dependencies නිසාත් conflicts ඇති වෙන්න පුළුවන්. ඒ වගේ වෙලාවට අපිට exclude keyword එක භාවිතා කරලා අනවශ්‍ය transitive dependency එකක් build එකෙන් අයින් කරන්න පුළුවන්.

dependencies {
    implementation ('org.springframework.boot:spring-boot-starter-logging') {
        exclude group: 'org.slf4j', module: 'slf4j-log4j12'
    }
}

Spring Boot වගේ Project වලදී, io.spring.dependency-management plugin එක මේ වගේ dependency conflicts ගොඩක් දුරට automate කරලා දෙනවා. ඒකෙන් පුළුවන් Spring Boot ecosystem එකේ හැම dependency එකක්ම එකිනෙකට compatible වෙන versions වලින් maintain කරන්න.

අවසන් වශයෙන්...

ඉතින් යාලුවනේ, අද අපි Gradle Dependencies සහ Plugins ගැන සරලව කතා කලා. මේවා අපේ Software Project එකක් develop කරනකොට, build කරනකොට සහ maintain කරනකොට ගොඩක්ම වැදගත් වෙන concepts දෙකක්.

Dependencies වලින් අපිට පුළුවන් අනිත් අය හදලා තියෙන code libraries අපේ Project එකට පහසුවෙන් එකතු කරගන්න. Plugins වලින් පුළුවන් Gradle වලට අලුත් features සහ capabilities එකතු කරලා build process එක තවත් පහසු කරන්න.

මේ Concepts දෙකම හොඳින් තේරුම් ගන්න එක අපේ Software Project එකක් සාර්ථකව Build කරලා Maintain කරන්න අත්‍යවශ්‍යයි. මුලින් මේවා පොඩ්ඩක් සංකීර්ණ වගේ පෙනුණත්, practice කරනකොට මේවා ගොඩක් පහසුයි. දැන් ඔයාලට පුළුවන් පොඩි Project එකක් හදලා මේවා apply කරලා බලන්න. Gradle documentation එකත් ගොඩක් හොඳ source එකක් වැඩිදුර දැනුම ලබාගන්න.

ඔයාලට මොනවා හරි ප්‍රශ්න තියෙනවා නම්, මේ ගැන තව මොනවා හරි දැනගන්න ඕන නම් පහලින් Comment කරන්න අමතක කරන්න එපා. ඔයාලගේ අදහස් සහ අත්දැකීම් බෙදාගන්නත් පුළුවන්. අපි ඊළඟ ලිපියෙන් තවත් වැදගත් මාතෘකාවකින් හම්බවෙමු! කෝඩින් වැඩේට ජය!