Maven Dependencies සහ Plugins: ඔබගේ Java Project පහසු කරගන්න!

ඉතින් කොහොමද යාලුවනේ? අද අපි කතා කරන්න යන්නේ Java ලෝකයේ අපේ ජීවිතේ ගොඩක් පහසු කරන සුපිරිම ටූල් එකක් ගැන – ඒ තමයි Maven. ඔයාලා දන්නවා ඇතිනේ, මොනම software project එකක් වුණත්, ඒක සාර්ථකව හදාගන්න අපිට ගොඩක් දේවල් එළියෙන් ඕන වෙනවා. හරියට ගෙයක් හදනකොට බඩු බාහිරාදියයි, විශේෂ මෙවලම් ටිකයි ඕන වෙනවා වගේ. මේ වැඩේට තමයි Maven කියන Project Management Tool එක අපිට උදව් කරන්නේ.

විශේෂයෙන්ම අපි කතා කරන්නේ Maven Dependencies සහ Plugins ගැන. මේ දෙක තමයි Maven වල හදවත වගේ. මේවා හරියට තේරුම් අරගෙන use කරන්න පුළුවන් නම්, ඔයාලගේ project එක manage කරන එක හිතුවටත් වඩා ලේසියි. සමහර වෙලාවට ඔයාලට දැනෙන්න පුළුවන් මේක ටිකක් අමාරු දෙයක් කියලා, ඒත් එහෙම නෑ. මම අද පුළුවන් තරම් සරලව මේ ගැන කියලා දෙන්නම්.

Maven කියන්නේ Build Automation Tool එකක්. ඒකෙන් පුළුවන් project එකේ code එක compile කරන්න, test කරන්න, packaging කරන්න, අනිත් අයට බෙදාහරින්න (deploy කරන්න) වගේ ගොඩක් වැඩ ටිකක් automate කරන්න. මේ හැමදේටම පදනම වෙන්නේ pom.xml කියන XML file එක. මේක තමයි අපේ project එකේ blueprint එක.

ආශ්‍රිත පුස්තකාල - Dependencies (නැත්නම් බඩු බාහිරාදිය)

අපි හිතමු ඔයාලා web application එකක් හදනවා කියලා. ඒකට ඔයාලට Spring Framework එකේ tools ඕනේ වෙන්න පුළුවන්. නැත්නම් database එකකට සම්බන්ධ වෙන්න Hibernate වගේ ORM එකක් ඕන වෙන්න පුළුවන්. එහෙමත් නැත්නම් unit tests ලියන්න JUnit වගේ framework එකක් ඕන වෙන්න පුළුවන්. මේ වගේ external libraries තමයි Dependencies කියලා කියන්නේ.

අපි මේවා manual download කරලා project එකට add කරන්න ගියොත්, ඒක හරිම අවුල් වැඩක්. Versions manage කරන එක, transitive dependencies manage කරන එක හරිම අමාරුයි. Maven මේ වැඩේ හරිම පහසුවෙන් කරලා දෙනවා. අපිට අවශ්‍ය library එකේ group id, artifact id, version එක pom.xml එකේ specify කරාම, Maven ඒක automate download කරලා, අපේ project එකට add කරලා දෙනවා. ඒ විතරක් නෙවෙයි, ඒ library එකට ඕන වෙන තවත් libraries (transitive dependencies) මොනවද කියලත් Maven හොයලා download කරනවා.

<dependencies>
    <!-- Spring Boot Starter Web Dependency -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
        <version>2.7.5</version>
    </dependency>

    <!-- JUnit 5 for testing -->
    <dependency>
        <groupId>org.junit.jupiter</groupId>
        <artifactId>junit-jupiter-api</artifactId>
        <version>5.9.1</version>
        <scope>test</scope>
    </dependency>

    <!-- MySQL Connector -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.31</version>
    </dependency>
</dependencies>

Dependency Scope එක මොකක්ද?

මේ <scope> කියන එක හරිම වැදගත්. මේකෙන් කියන්නේ මේ dependency එක project එකේ කොයි වෙලාවටද use වෙන්න ඕනේ කියලා. ප්‍රධාන scope වර්ග කීපයක් තියෙනවා:

• compile: මේක default scope එක. dependency එක compile time එකෙත්, runtime එකෙත් දෙකේම use වෙනවා. අපේ project එක deploy කරනකොටත් මේ dependency එක deploy වෙනවා. (උදා: Spring Boot Starter Web)
• provided: මේ scope එකෙන් කියන්නේ dependency එක compile time එකේදී ඕන කරනවා, ඒත් runtime එකේදී ඒක Servlet Container එකක් (Tomcat වගේ) නැත්නම් Application Server එකක් provide කරනවා කියලා. (උදා: javax.servlet-api)
• runtime: මේ dependency එක compile time එකේදී ඕන වෙන්නේ නෑ. ඒත් project එක run කරනකොට ඕන වෙනවා. (උදා: JDBC drivers වගේ දේවල්)
• test: මේ scope එකෙන් කියන්නේ dependency එක test code compile කරන්න සහ run කරන්න විතරයි use වෙන්නේ කියලා. Project එක deploy කරනකොට මේවා deploy වෙන්නේ නෑ. (උදා: JUnit, Mockito)
• system: මේකෙන් පුළුවන් අපේ local file system එකේ තියෙන jar file එකක් dependency එකක් විදිහට add කරන්න. මේක ගොඩක් වෙලාවට use වෙන්නේ නැති වුණත්, සමහර special cases වලට ඕන වෙනවා.

හරි, දැන් ඔයාලට dependencies ගැන හොඳ අදහසක් ඇති. ඊළඟට අපි යමු project එකේ වැඩ කරන්න ඕන කරන tools, ඒ කියන්නේ Plugins ගැන කතා කරන්න.

ප්ලගින - Plugins (නැත්නම් විශේෂ මෙවලම්)

අපි ගෙයක් හදනකොට ගඩොල්, සිමෙන්ති වගේ බඩු බාහිරාදියට අමතරව, බිත්ති බඳින්න ඕන කරන මෙවලම්, වහල ගහන්න ඕන කරන මෙවලම් වගේ විශේෂ මෙවලම් ඕන වෙනවා නේද? Maven Plugins කියන්නෙත් ඒ වගේමයි. Maven එකේ හැම වැඩක්ම වගේ කරන්නේ Plugins වලින්. Code compile කරන එක, tests run කරන එක, project එක jar/war file එකක් විදිහට package කරන එක, documentation generate කරන එක වගේ හැම දේටම Plugins use වෙනවා.

Plugins කියන්නේ Maven එකට අපි දෙන instructions set එකක් වගේ. මේවා <build> section එක ඇතුලේ <plugins> කියන tag එක යටතේ specify කරනවා. එක plugin එකකට එකක් හෝ කීපයක් ‘goals’ තියෙන්න පුළුවන්. මේ goals තමයි plugin එකෙන් කරන්න පුළුවන් විශේෂ වැඩ ටික.

<build>
    <plugins>
        <!-- Maven Compiler Plugin -->
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.10.1</version>
            <configuration>
                <source>1.8</source> <!-- Source compatibility -->
                <target>1.8</target> <!-- Target compatibility -->
            </configuration>
        </plugin>

        <!-- Maven Surefire Plugin for running tests -->
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-surefire-plugin</artifactId>
            <version>2.22.2</version>
            <configuration>
                <skipTests>false</skipTests> <!-- Set to true to skip tests -->
            </configuration>
        </plugin>

        <!-- Maven WAR Plugin (for web projects) -->
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-war-plugin</artifactId>
            <version>3.3.2</version>
            <configuration>
                <failOnMissingWebXml>false</failOnMissingWebXml>
            </configuration>
        </plugin>
    </plugins>
</build>

ඉහත උදාහරණයේ තියෙන්නේ ගොඩක්ම use වෙන plugin කීපයක්. maven-compiler-plugin එකෙන් කරන්නේ අපේ Java source code එක compile කරන එක. maven-surefire-plugin එකෙන් unit tests run කරනවා. ඒ වගේම maven-war-plugin එකෙන් web application එකක් deploy කරන්න පුළුවන් WAR (Web Archive) file එකක් හදනවා.

Build Plugins vs. Reporting Plugins

සාමාන්‍යයෙන් Maven Plugins වර්ග දෙකකට වෙන් කරන්න පුළුවන්:

• Build Plugins: මේවා project build process එකේදී run වෙනවා. (උදා: compiler, surefire, jar, war plugins)
• Reporting Plugins: මේවා project එකේ reports generate කරන්න use වෙනවා. (උදා: Javadoc, Surefire Report, Checkstyle reports)

ඔයාලට ඕන නම් plugin එකක default behavior එක වෙනස් කරන්න පුළුවන් <configuration> tag එක ඇතුලේ. ඒ වගේම, සමහර plugins Maven lifecycle phases වලට auto-bind වෙනවා. උදාහරණයක් විදිහට, maven-compiler-plugin එක compile phase එකට, maven-surefire-plugin එක test phase එකට automatically bind වෙනවා. ඒ කියන්නේ අපි mvn compile, mvn test වගේ commands run කරනකොට අදාළ plugins run වෙනවා.

ප්‍රායෝගික භාවිත සහ උපදෙස් (Practical Usage & Tips)

දැන් අපි කතා කරපු දේවල් තවදුරටත් project එකකදී කොහොමද හරියට use කරන්නේ, සහ පොඩි tips කීපයක් මොනවද කියලා බලමු.

Dependencies හොයාගන්නේ කොහොමද?

අපිට ඕන ඕනම library එකක dependency එක හොයාගන්න පුළුවන් ප්‍රධාන තැනක් තමයි Maven Central Repository. මේ site එකට ගිහින් ඔයාලට ඕන library එක search කරලා, අදාළ version එක click කරාම, ඒකේ dependency XML snippet එක copy කරගන්න පුළුවන්. හරිම ලේසියි.

Dependency Management

විශාල project වල dependencies ගොඩක් තියෙනවා. ඒ හැම එකකම version එක control කරන එක ටිකක් අමාරුයි. ඒකට Maven එකේ තියෙනවා <dependencyManagement> කියන section එක. මේක <project> tag එක ඇතුලේ දාන්න පුළුවන්. මේකෙන් කරන්නේ, අපි මෙතන dependencies වල versions define කරනවා. ඊට පස්සේ <dependencies> section එකේදී ඒ dependencies add කරනකොට version එක දාන්නේ නැතුව use කරන්න පුළුවන්. මේක parent POM එකක වගේ තියාගත්තම, project එකේ හැම module එකකටම එකම version එක use කරන්න පුළුවන්.

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-dependencies</artifactId>
            <version>2.7.5</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.13.4</version>
        </dependency>
    </dependencies>
</dependencyManagement>

ඊට පස්සේ, <dependencies> section එකේදී මෙහෙම add කරන්න පුළුවන්:

<dependencies>
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
        <!-- Version is inherited from dependencyManagement -->
    </dependency>
</dependencies>

මේකෙන් dependency hell එක අඩු කරගන්න පුළුවන්. හැමතැනම එකම dependency එකේ versions වෙනස් වෙන එක වළක්වාගන්නත් පුළුවන්.

Plugin Configuration සහ Executions

සමහර වෙලාවට අපිට plugin එකක් අපේ ඕනෑවට අනුව හැසිරෙන්න customize කරන්න වෙනවා. ඒකට <configuration> tag එක use කරනවා. උදාහරණයක් විදිහට, maven-compiler-plugin එකේදී Java version එක specify කරනවා වගේ. තව දුරටත්, එකම plugin එකෙන් වෙනස් goals, වෙනස් phases වලදී run කරන්න ඕන නම්, <executions> කියන tag එක use කරන්න පුළුවන්.

<plugin>
    <groupId>org.codehaus.mojo</groupId>
    <artifactId>exec-maven-plugin</artifactId>
    <version>3.1.0</version>
    <executions>
        <execution>
            <id>my-custom-task</id>
            <goals>
                <goal>java</goal>
            </goals>
            <configuration>
                <mainClass>com.example.MyMainClass</mainClass>
            </configuration>
        </execution>
    </executions>
</plugin>

පොදු ගැටලු සහ විසඳුම්

• Dependency Conflicts: එකම library එකේ versions දෙකක් project එකට ඇඩ් වෙලා තිබ්බොත් errors එන්න පුළුවන්. mvn dependency:tree command එකෙන් dependency tree එක බලාගෙන මොකද වෙලා තියෙන්නේ කියලා හොයාගන්න පුළුවන්. <exclusions> tag එක use කරලා අනවශ්‍ය transitive dependency එකක් exclude කරන්න පුළුවන්.
• Plugin Not Found: සමහර වෙලාවට internet connection එකක් නැත්නම්, Maven local repository එකේ plugin එක නැත්නම් මේ error එක එනවා. mvn clean install වගේ run කරලා බලන්න.
• Java Version Issues: maven-compiler-plugin එකේ source සහ target versions හරියට specify කරලා නැත්නම් compile errors එන්න පුළුවන්.

අවසාන වශයෙන් (Wrapping Up)

ඉතින් යාලුවනේ, අද අපි Maven Dependencies සහ Plugins ගැන සවිස්තරාත්මකව කතා කළා. මේ දෙක තමයි ඕනෑම Java Project එකක හදවත වගේ. මේවා හරියට තේරුම් අරගෙන, pom.xml file එක හරියට configure කරගන්න පුළුවන් නම්, ඔයාලගේ project management එක හරිම ලේසියි. දන්නවනේ, project එකක් කියන්නේ නිකන් code ලියන එක විතරක් නෙවෙයි, ඒක හරියට organize කරලා, build කරලා, test කරලා, deploy කරන එකත් ගොඩක් වැදගත්.

මේ ගැන ඔයාලට මොනවා හරි ප්‍රශ්න තියෙනවා නම්, නැත්නම් ඔයාලගේ අත්දැකීම් කොහොමද කියලා කියන්න පුළුවන් නම්, පහළින් comment එකක් දාන්න. අපි ඒ ගැන තවදුරටත් කතා කරමු. මතක තියාගන්න, practice කරන එක තමයි වැදගත්ම දේ. පොඩි test project එකක් හදලා මේවා try කරලා බලන්න. එතකොට තව හොඳට තේරෙයි.

ඉදිරියේදී තවත් මෙවැනිම වටිනා ලිපියකින් හමුවෙමු! Stay tuned!