Maven Build Tool - හැඳින්වීම | Dependency Management SC Guide

ආයුබෝවන්, හැමෝටම!

අද අපි කතා කරන්න යන්නේ software development වලදී, විශේෂයෙන්ම Java ecosystem එක ඇතුළේ, අත්‍යවශ්‍යම tool එකක් ගැන. ඒ තමයි Maven Build Tool එක. කට්ටියට මේක ගැන අහලා ඇති, සමහරු දිනපතාම වගේ වැඩ කරනවා ඇති. ඒත් මේක ඇත්තටම මොකක්ද? මොකටද මේකෙන් කරන්නේ? කියන එක ගැන සරලව, අපේ සිංහලෙන් කතා කරමු.

ඔබ Java developer කෙනෙක් නම්, project එකක වැඩ කරනවා නම්, dependency management, project building කියන දේවල්වලදී headaches කීයක් විතර ඇති වෙනවද කියලා දන්නවා ඇති. Libraries හොයලා එකතු කරන එක, එක එක version compatibility issues, build process එක manage කරන එක... අයියෝ, වැඩේ සෑහෙන්න complicated වෙන්න පුළුවන්. මේ වගේ අවස්ථාවලදී අපේ ජීවිතේ සෑහෙන්න පහසු කරන tool එකක් තමයි Maven කියන්නේ. මේ article එකෙන් අපි Maven කියන්නේ මොකක්ද, ඒකෙන් මොනවද කරන්න පුලුවන්, කොහොමද ඒක පාවිච්චි කරන්නේ කියන දේවල් මුල ඉඳලම බලමු.

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

සරලව කිව්වොත්, Maven කියන්නේ project build automation tool එකක්. Apache Software Foundation එකෙන් තමයි මේක develop කරලා තියෙන්නේ. මේක Java project manage කරන්න හදලා තිබ්බත්, වෙනත් programming languages වලටත් මේක extend කරන්න පුළුවන්. Maven වල ප්‍රධානම අරමුණ තමයි project build process එක standardize කරලා, simplify කරන එක.

ඔබ project එකක් develop කරනකොට, ඒකට external libraries ගොඩක් ඕන වෙනවා නේද? උදාහරණයක් විදියට, Spring Framework, Hibernate, Apache Commons වගේ දේවල්. මේ හැම library එකක්ම අතින් download කරලා, project classpath එකට එකතු කරන එක කියන්නේ සෑහෙන්න මහන්සි වෙන්න ඕන වැඩක්. ඒ වගේම, මේ libraries වල versions manage කරන එක, ඒවගේ transitive dependencies (එක dependency එකක් නිසා තව dependencies ගොඩක් ඕන වෙන එක) manage කරන එකත් සෑහෙන්න අමාරුයි. Maven මෙන්න මේ වගේ දේවල් සෑහෙන්න පහසු කරනවා.

Maven වල තියෙන ප්‍රධානම concept එකක් තමයි Convention over Configuration කියන එක. ඒ කියන්නේ, project එකක් build කරන්න අවශ්‍ය default settings ගොඩක් Maven එකේ කලින් තියෙනවා. ඒ නිසා අපි හැමදේම specify කරන්න ඕනේ නැහැ. උදාහරණයක් විදියට, Maven project එකක source code එක තියෙන්නේ src/main/java කියන folder එකේ කියලා Maven දන්නවා. Tests තියෙන්නේ src/test/java folder එකේ කියලා දන්නවා. මේ default conventions නිසා අපිට code කරන එකටම අවධානය දෙන්න පුළුවන්, build configuration එක ගැන වැඩිපුර හිතන්න ඕනේ නැහැ.

Maven ප්‍රධාන වශයෙන්ම focus කරන්නේ මේ දේවල් මතයි:

• Dependency Management: Project එකට අවශ්‍ය Libraries (dependencies) automate විදියට manage කරන එක.
• Build Process: Source code compile කරන එක, tests run කරන එක, packages (JAR, WAR, EAR) හදන එක වගේ build process එක automate කරන එක.
• Project Information: Project එකේ details (version, dependencies, developers) organize කරලා reports හදන එක.

Dependency Management පහසුවෙන්

Maven වල බලවත්ම feature එකක් තමයි dependency management. Project එකක dependencies manage කරන්න කලින් දවස්වල developer කෙනෙක්ට external JAR files download කරලා, manually project එකේ classpath එකට එකතු කරන්න වුණා. මේක සෑහෙන්න කාලය නාස්ති කරන, වැරදි වෙන්න පුළුවන් වැඩක්.

Maven මෙතැනදී වැඩේ සෑහෙන්න පහසු කරනවා. කොහොමද කියලා බලමු:

හැම Maven project එකකම pom.xml (Project Object Model) කියලා XML file එකක් තියෙනවා. මේක තමයි project එකේ blueprint එක වගේ. මේ file එක ඇතුළේ අපි project එකේ name, version, dependencies, build configurations වගේ හැම විස්තරයක්ම specify කරනවා.

උදාහරණයක් විදියට, අපේ project එකට Apache Commons Lang library එක ඕනේ නම්, අපි pom.xml file එකේ <dependencies> tag එක ඇතුළේ මෙහෙම specify කරනවා:

<dependencies>
    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-lang3</artifactId>
        <version>3.12.0</version>
    </dependency>
</dependencies>

මේ ටික add කරාම, අපි project එක build කරනකොට Maven automatically මේ library එක Maven Central Repository එකෙන් download කරලා, අපේ project එකට එකතු කරනවා. එතකොට අපිට manual download කිරීම්, classpath එක modify කිරීම් වගේ දේවල් ගැන කරදර වෙන්න ඕනේ නැහැ.

තව වැදගත් දෙයක් තමයි transitive dependencies. අපි dependency එකක් add කරාම, ඒ dependency එකටත් තව dependencies ගොඩක් ඕන වෙන්න පුළුවන්. Maven මේ හැම transitive dependency එකක්ම identify කරලා, automate විදියට manage කරනවා. ඒ නිසා අපි කරදර වෙන්න ඕනේ නැහැ.

Project Build එක automate කරමු

Maven කියන්නේ build automation tool එකක් නිසා, project එකක් compile කරන එක, test කරන එක, deploy කරන එක වගේ දේවල් සෑහෙන්න පහසු කරනවා. Maven වල තියෙන build lifecycle concept එක මෙතැනදී ගොඩක් වැදගත් වෙනවා.

Maven build lifecycle එක කියන්නේ, project build process එකේ phases ගොඩක එකතුවක්. මේවා නිශ්චිත අනුපිළිවෙලකට තමයි execute වෙන්නේ. ප්‍රධානම lifecycle එක තමයි default lifecycle එක. ඒකේ වැදගත් phases කිහිපයක් මෙන්න:

• validate: Project එක valid ද, අවශ්‍ය සියලුම information තියෙනවද කියලා check කරනවා.
• compile: Source code compile කරනවා.
• test: Compiled source code test කරනවා (unit tests).
• package: Compiled code එක JAR, WAR, EAR වගේ distribution format එකකට package කරනවා.
• integration-test: Integration tests run කරනවා.
• verify: Integration test results verify කරනවා.
• install: Package එක local Maven repository එකට install කරනවා (අපේ machine එකේ).
• deploy: Package එක remote repository එකකට deploy කරනවා (උදා: Nexus, Artifactory).

මේ phases එකින් එකට execute වෙනවා. උදාහරණයක් විදියට, අපි mvn install කියලා run කරොත්, validate, compile, test, package යන phases execute වෙලා තමයි install phase එකට එන්නේ. ඒ කියන්නේ, install කියන එක package එකට කලින් run වෙන phases ටිකත් execute කරනවා.

Maven command line එකේදී අපි මේ phases run කරන්නේ මෙහෙමයි:

mvn clean install

මෙහිදී:

• clean: මේක වෙනම lifecycle එකක්. මේකෙන් කරන්නේ කලින් build එකෙන් හදපු files (උදා: target folder එක) delete කරන එක. අලුතෙන් clean build එකක් ගන්න මේක ගොඩක් ප්‍රයෝජනවත්.
• install: මේකෙන් project එක compile කරලා, test කරලා, package කරලා, local Maven repository එකට install කරනවා.

තව වැදගත් command එකක් තමයි mvn package. මේකෙන් project එක compile කරලා, test කරලා, distribution package එකක් (JAR, WAR) හදනවා. හැබැයි මේක local repository එකට install කරන්නේ නැහැ.

Maven plugins කියන්නේ build process එක customize කරන්න පාවිච්චි කරන extensions. compile කරන එකට compiler plugin එකක් තියෙනවා, test කරන එකට surefire plugin එකක් තියෙනවා වගේ. මේවා pom.xml එකේ <build> section එක ඇතුළේ configure කරන්න පුළුවන්.

ප්‍රායෝගික උදාහරණයක්: පළමු Maven Project එක

හරි, දැන් අපි Maven ගැන theoretical දැනුමක් ගත්තා. දැන් බලමු practical විදියට Maven project එකක් කොහොමද පටන් ගන්නේ කියලා. මේක කරන්න අපිට Maven install කරලා තියෙන්න ඕනේ. (ඒක ගැන දැනට නොදන්නවා නම්, Google search එකක් දාලා install කරගන්න පුළුවන්.)

අපි new project එකක් හදන්න command line එක පාවිච්චි කරමු:

mvn archetype:generate -DgroupId=com.mycompany.app -DartifactId=my-first-app -DarchetypeArtifactId=maven-archetype-quickstart -DarchetypeVersion=1.4 -DinteractiveMode=false

මේ command එකෙන් වෙන්නේ:

• archetype:generate: Maven archetype plugin එක පාවිච්චි කරලා new project එකක් generate කරනවා. Archetype එක කියන්නේ project template එකක් වගේ.
• -DgroupId=com.mycompany.app: Project එකේ unique identifier එක. සාමාන්‍යයෙන් domain name එක reverse කරලා තමයි මේක දෙන්නේ.
• -DartifactId=my-first-app: Project එකේ නම.
• -DarchetypeArtifactId=maven-archetype-quickstart: අපි පාවිච්චි කරන archetype template එක. මේක basic Java project එකකට හොඳයි.
• -DarchetypeVersion=1.4: Archetype එකේ version එක.
• -DinteractiveMode=false: Interactive mode එක off කරනවා. නැත්නම් project details එකින් එකට අහනවා.

මේ command එක run කරාම, my-first-app කියලා folder එකක් හැදෙනවා. ඒක ඇතුළේ මෙන්න මේ වගේ structure එකක් තියෙනවා:

my-first-app/
├── pom.xml
└── src/
    ├── main/
    │   └── java/
    │       └── com/
    │           └── mycompany/
    │               └── app/
    │                   └── App.java
    └── test/
        └── java/
            └── com/
                └── mycompany/
                    └── app/
                        └── AppTest.java

දැන් අපි බලමු pom.xml file එක:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.mycompany.app</groupId>
    <artifactId>my-first-app</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.7</maven.compiler.source>
        <maven.compiler.target>1.7</maven.compiler.target>
    </properties>

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <pluginManagement><plugins>
            <plugin>
                <artifactId>maven-clean-plugin</artifactId>
                <version>3.1.0</version>
            </plugin>
            <plugin>
                <artifactId>maven-resources-plugin</artifactId>
                <version>3.0.2</version>
            </plugin>
            <plugin>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.0</version>
            </plugin>
            <plugin>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>2.22.1</version>
            </plugin>
            <plugin>
                <artifactId>maven-jar-plugin</artifactId>
                <version>3.0.2</version>
            </plugin>
            <plugin>
                <artifactId>maven-install-plugin</artifactId>
                <version>2.5.2</version>
            </plugin>
            <plugin>
                <artifactId>maven-deploy-plugin</artifactId>
                <version>2.8.2</version>
            </plugin>
            <plugin>
                <artifactId>maven-site-plugin</artifactId>
                <version>3.7.1</version>
            </plugin>
            <plugin>
                <artifactId>maven-project-info-reports-plugin</artifactId>
                <version>3.0.0</version>
            </plugin>
        </plugins></pluginManagement>
    </build>
</project>

මේ pom.xml එකේ project details, JUnit dependency එක (tests වලට), build properties (Java version) වගේ දේවල් තියෙනවා. අපි මේකේ maven.compiler.source සහ maven.compiler.target values 1.7 වෙනුවට 1.8 හෝ ඔබට අවශ්‍ය ඕනෑම නවතම Java version එකකට වෙනස් කරන්න පුළුවන්.

Project එක Build කරමු

දැන් අපි my-first-app folder එක ඇතුලට ගිහින් project එක build කරමු:

cd my-first-app
mvn clean install

Command එක run කරාම, Maven අවශ්‍ය dependencies download කරනවා (පළවෙනි පාරට නම් ටිකක් වෙලා යයි), source code compile කරනවා, tests run කරනවා, අන්තිමට my-first-app-1.0-SNAPSHOT.jar කියන JAR file එක target folder එක ඇතුළේ හදනවා. ඒ JAR file එක local Maven repository එකටත් (සාමාන්‍යයෙන් ~/.m2/repository) install කරනවා.

target folder එක බැලුවොත්, ඒක ඇතුළේ compiled classes, test results, final JAR file එක වගේ දේවල් තියෙනවා:

my-first-app/
├── pom.xml
├── src/
└── target/
    ├── classes/
    │   └── com/
    │       └── mycompany/
    │           └── app/
    │               └── App.class
    ├── generated-sources/
    ├── generated-test-sources/
    ├── maven-archiver/
    ├── maven-status/
    ├── surefire-reports/
    ├── test-classes/
    │   └── com/
    │       └── mycompany/
    │           └── app/
    │               └── AppTest.class
    └── my-first-app-1.0-SNAPSHOT.jar

දැන් බලන්න, අපි ලොකු දෙයක් කළේ නැහැ. ඒත් Maven වැඩේ නියමෙට automate කරලා දුන්නා. මේක තමයි Maven වල සිරාම වැඩේ.

අවසාන වශයෙන්

Maven Build Tool එක කියන්නේ modern software development වලදී අත්‍යවශ්‍යම tool එකක්. dependency headaches නැති කරගන්න, project build process එක streamline කරගන්න, ඒ වගේම project එකේ quality එක maintain කරන්න මේක ගොඩක් උදව් වෙනවා. Java ecosystem එකේ ඉන්න කෙනෙක්ට Maven නැතුව ඉන්න බැහැ වගේ තත්ත්වයක් තමයි දැන් තියෙන්නේ.

අද අපි Maven ගැන මූලිකම දේවල් ටිකක් කතා කළා. මේකෙන් ඔයාලට Maven කියන්නේ මොකක්ද, ඒකෙන් මොනවද කරන්න පුළුවන්, කොහොමද ඒක පටන් ගන්නේ කියන එක ගැන හොඳ අවබෝධයක් ලැබෙන්න ඇති කියලා හිතනවා. මෙතනින් එහාට Maven project එකක් ඔයාලගේ IDE එකකට (IntelliJ IDEA, Eclipse) import කරලා වැඩ කරන්න පුරුදු වෙන්න. එතකොට තව ගොඩක් features ගැන ඉගෙන ගන්න පුළුවන් වෙයි.

මේ article එකෙන් ඔයාලට අලුත් දෙයක් ඉගෙන ගන්න ලැබුණා නම්, අනිවාර්යයෙන්ම පහළින් comment එකක් දාගෙන යන්න. ප්‍රශ්න තියෙනවා නම් ඒවත් අහන්න. අපි ඒවට උත්තර දෙන්න පුලුවන් විදියට උදව් කරන්නම්. එහෙනම්, තවත් මෙවැනිම වටිනා ලිපියකින් හමුවෙමු!