Spring Framework Basics: The SC Guide

ආයුබෝවන් කට්ටියටම! කොහොමද ඉතින්? Software Engineering කියන මේ ලෝකේ දවසින් දවස අලුත් දේවල් එනවා. ඒත් සමහර core technologies තියෙනවා, ඒවාට තියෙන වටිනාකම කවදාවත් අඩුවෙන්නේ නෑ. Java ecosystem එකේ ඉන්න කෙනෙක් නම්, ඔයාලට Spring Framework එක ගැන අහලා නැතුවම ඇති කියලා හිතන්න අමාරුයි. මේක කියන්නෙ අපේ developer ලගේ ජීවිතේ හුඟක් පහසු කරපු amazing Framework එකක්. අද අපි කතා කරමු Spring Framework එකේ තියෙන basics ටිකක්, විශේෂයෙන්ම IoC (Inversion of Control) සහ DI (Dependency Injection) කියන concepts ගැන. මොකද, මේ දෙක තමයි Spring Framework එකේ හදවත වගේම, Spring Boot ඉගෙන ගන්න කලින් අනිවාර්යයෙන්ම දැනගන්න ඕන දේවල්.

ඔයාලා Java developer කෙනෙක් වෙන්න හීන දකින, නැත්නම් දැනටමත් developer කෙනෙක් විදිහට වැඩ කරන කෙනෙක් වුණත්, Spring Framework එක නොදැන ඉන්න එක පාඩුවක්. ලංකාවේ වුණත්, ලෝකේ වුණත් Java projects ගොඩක් use කරන්නේ Spring Framework එක. ඉතින්, තවදුරටත් කල් නොදා අපි මේක ගැන ඉගෙන ගමු. පොඩි පොඩි කතාත් එක්කම යමුද?

1. Spring Framework කියන්නේ මොකද්ද? (අපි කවුද? අපි මොකද කරන්නේ?)

සරලවම කිව්වොත්, Spring Framework කියන්නේ Java applications හදන්න පුදගලිකව උදව් කරන comprehensive framework එකක්. මේක අපිට Enterprise-level applications ඉඳන්, microservices, web apps වගේ දේවල් හදන්න අවශ්‍ය tools, infrastructure සපයනවා. මේක හැදුවේ SpringSource (දැන් Pivotal, VMware යටතේ) කියන කට්ටිය. Spring Framework එකේ තියෙන විශේෂත්වය තමයි modularity එක. ඒ කියන්නේ, අපිට ඕන component එක විතරක් use කරන්න පුළුවන්. උදාහරණයක් විදිහට, Spring Data, Spring MVC, Spring Security වගේ modules ගොඩක් තියෙනවා. අපිට අවශ්‍ය දේ තෝරගෙන වැඩ කරන්න පුළුවන්.

Spring Framework එකේ ප්‍රධානම දේවල් දෙකක් තමයි අපි අද කතා කරන IoC සහ DI කියන concepts. මේවා තමයි Spring වල Magic එක පිටිපස්සේ තියෙන Theory එක. මේවා නිසා තමයි Spring Framework එක applications develop කරන්න ලේසි, maintain කරන්න ලේසි, test කරන්න ලේසි වෙන්නේ.

2. IoC (Inversion of Control) - "මගේ වැඩේ මම බැලුවේ නෑ, Spring බැලුවා!"

IoC කියන්නේ "Inversion of Control" වල කෙටි නම. මේක තේරුම් ගන්න පොඩි උදාහරණයක් ගමු. සාමාන්‍යයෙන් ඔයාලා software එකක් හදනකොට, ඔයාලට Class A එකක් ඇතුළේ Class B එකක් ඕන වුණොත්, ඔයාලා කරන්නේ Class A ඇතුළේ Class B එකේ object එකක් new B() කියලා හදන එක නේද? මෙතනදි, Class A එක තීරණය කරනවා Class B එකේ object එක හදන්නේ කොහොමද, කවදද, කොතනද කියලා. මේක තමයි traditional way එක.

IoC concept එකෙන් කියන්නේ, මේ control එක (object creation, dependency management වගේ) අපි වෙන කෙනෙක්ට දෙනවා කියන එක. ඒ 'වෙන කෙනා' තමයි Spring Framework එක. අපි Spring Framework එකට කියනවා "මට මේ Class එකේ object එකක් ඕන, මේ Class එකට මේ Class එක dependency එකක් විදිහට ඕන" කියලා. ඊට පස්සේ, Spring Framework එක තීරණය කරනවා ඒ object එක හදන්නේ කොහොමද, ඒ dependencies ටික supply කරන්නේ කොහොමද කියලා. ඒ කියන්නේ, control එක අපෙන් අරන්, Spring Framework එකට දීලා තියෙනවා.

මේක හරියට, ඔයාලා රෙස්ටුරන්ට් එකකට ගිහින් කෑමක් ඕඩර් කරනවා වගේ. ඔයාලා Chef ට කියන්නේ නෑ, "මේක හදන්න මට මේ එලවලු ඕන, මේ කුළුබඩු ඕන" කියලා. ඔයාලා කියන්නේ "මට බිරියානි එකක් ඕන" කියලා විතරයි. Chef ඒක හදලා දෙනවා. මෙතනදි Chef ට තමයි control එක තියෙන්නේ. ඒ වගේම තමයි IoC කියන්නෙත්. අපි (developers) අපේ objects හදන control එක Spring Framework එකට දෙනවා.

ඇයි මේක හොඳ?

• Loose Coupling: අපේ classes එකිනෙකට තදින් බැඳිලා නැති වෙනවා. ඒ නිසා, එක Class එකක වෙනසක් වුණොත් අනිත් Class එකට බලපාන එක අඩුයි.
• Easy Testing: Dependencies inject කරන නිසා, Mock objects දාලා test කරන්න හරිම ලේසියි.
• Modularity: Code එක කොටස් වලට බෙදාගන්න ලේසියි.

3. DI (Dependency Injection) - "අවශ්‍ය දේවල් Spring ගෙනත් දෙනවා!"

DI කියන්නේ "Dependency Injection" වල කෙටි නම. මේක IoC concept එක implement කරන ක්‍රමයක්. IoC කියන්නේ concept එක, DI කියන්නේ ඒක ක්‍රියාවට නංවන method එක. සරලවම කිව්වොත්, Class එකකට අවශ්‍ය වෙන objects (dependencies) ඒ Class එක ඇතුළෙම හදන්නේ නැතුව, පිටින් supply කරන එක තමයි DI කියන්නේ. Spring Framework එක මේක කරන්නේ අපේ classes වලට dependencies inject කරනවා කියලා. මේක ප්‍රධාන ක්‍රම තුනකට කරන්න පුළුවන්:

1. Constructor Injection: Class එකේ constructor එකට dependencies ටික pass කරන එක.
2. Setter Injection: Class එකේ setter methods හරහා dependencies සපයන එක.
3. Field Injection: Class එකේ fields වලට කෙලින්ම dependencies inject කරන එක. (නමුත් මෙය එතරම් හොඳ ක්‍රමයක් ලෙස නොසලකයි, testability අඩු නිසා)

අපි Constructor Injection ක්‍රමය ගැන පොඩි Java code snippet එකකින් බලමු:

// Service Interface
interface MessageService {
    String getMessage();
}

// Implementation of the Service
class EnglishMessageService implements MessageService {
    @Override
    public String getMessage() {
        return "Hello from English Service!";
    }
}

// Another Implementation
class SinhalaMessageService implements MessageService {
    @Override
    public String getMessage() {
        return "ආයුබෝවන් සිංහල සේවාවෙන්!";
    }
}

// Class that depends on MessageService
class ApplicationProcessor {
    private final MessageService messageService;

    // Constructor Injection
    public ApplicationProcessor(MessageService messageService) {
        this.messageService = messageService;
    }

    public void processMessage() {
        System.out.println(messageService.getMessage());
    }
}

මේ උදාහරණයේ, ApplicationProcessor class එකට MessageService එකක් අවශ්‍යයි. අපි ApplicationProcessor එක ඇතුළේ new EnglishMessageService() කියලා හදන්නේ නෑ. ඒ වෙනුවට, අපි MessageService එක constructor එක හරහා request කරනවා. Spring Framework එක මේ ApplicationProcessor object එක හදනකොට, ඒකට අවශ්‍ය MessageService object එකක් (EnglishMessageService එකක් හෝ SinhalaMessageService එකක්) inject කරනවා. මේක තමයි DI.

Spring Boot වලදී, @Autowired annotation එක use කරලා මේක ලේසියෙන්ම කරන්න පුළුවන්. Spring Boot එක auto-configure කරලා dependencies inject කරනවා.

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
class EnglishMessageService implements MessageService {
    @Override
    public String getMessage() {
        return "Hello from English Service (Spring Boot)! ";
    }
}

@Service
class ApplicationProcessor {
    private final MessageService messageService;

    @Autowired // Spring automatically injects an instance of MessageService
    public ApplicationProcessor(MessageService messageService) {
        this.messageService = messageService;
    }

    public void processMessage() {
        System.out.println(messageService.getMessage());
    }
}

මෙහිදී @Service annotation එකෙන් Spring Framework එකට කියනවා මේවා Spring managed components කියලා. @Autowired annotation එකෙන් කියනවා මේක dependency එකක්, Spring මේක inject කරන්න ඕනේ කියලා.

4. IoC Container (ApplicationContext) - Spring වල "Boss"

ඉතින් මේ IoC සහ DI කියන concepts ක්‍රියාවට නංවන්නේ කවුද? ඒ තමයි IoC Container එක. Spring Framework එකේ IoC Container එක ApplicationContext interface එකෙන් define වෙනවා. මේ Container එක තමයි අපේ application එකේ තියෙන objects (මේවාට Spring වලදී "beans" කියනවා) create කරන්නේ, configure කරන්නේ, සහ manage කරන්නේ. ඒ කියන්නේ, අපි හදන Classes වල objects, ඒවාට අවශ්‍ය dependencies වගේ හැමදේම Spring Container එක manage කරනවා. හරියට ෆැක්ටරියක Boss කෙනෙක් වගේ, එයා තමයි හැමදේම බලන්නේ, හැමදේම සම්බන්ධ කරන්නේ. මේ Beans වල lifecycle එකත් මේ Container එකෙන් manage කරනවා.

5. Spring Boot වලට මේක කොහොමද?

දැන් ඔයාලා හිතනවා ඇති, අපි කතා කළේ Spring Framework ගැන නේද, Spring Boot කොහෙද මෙතනට ආවේ කියලා. ඇත්තටම Spring Boot කියන්නේ Spring Framework එකේම extension එකක්. Spring Framework එකේ තියෙන IoC, DI වගේ core concepts ඒ විදිහටම Spring Boot වලත් තියෙනවා. Spring Boot කරන්නේ මේ දේවල් configure කරන එක හරිම ලේසි කරන එක. Auto-configuration, convention over configuration වගේ දේවල් නිසා අපිට boilerplate code ලියන එක අඩු වෙනවා. ඒ කියන්නේ, Spring Boot එකෙන් Spring Framework එක පාවිච්චි කරන එක තවත් පහසු කරනවා. හැබැයි, ඒ පහසුව පිටිපස්සේ තියෙන්නේ මේ IoC, DI කියන core principles ටිකම තමයි.

ඉතින්, ඔයාලා Spring Boot ගැන ඉගෙන ගන්න කලින් මේ Spring Framework වල IoC, DI concepts පැහැදිලිව තේරුම් ගන්න එක හරිම වැදගත්. මොකද, මේවා තමයි Spring Boot වල "magic" එකේ පදනම.

අවසන් වචනය සහ අභියෝගය!

හරි, අද අපි Spring Framework එකේ තියෙන ප්‍රධානම concepts දෙකක් ගැන කතා කළා. IoC කියන්නේ control එක අපි වෙන කෙනෙක්ට දෙන එක. DI කියන්නේ ඒ control එකේ කොටසක් විදිහට dependencies inject කරන එක. මේවා තමයි Spring Framework එක මෙච්චර බලවත් වෙන්න හේතුව. මේ concepts තේරුම් ගත්තා නම්, Spring Boot වලට එන එක ඔයාලට හරිම ලේසි වෙයි.

ඉතින්, මේක අහලා විතරක් නවතින්න එපා. පුළුවන් නම් ඔයාලම පොඩි Java project එකක් හදලා, Spring Framework use කරලා Constructor Injection එකක් implement කරලා බලන්න. Spring Docs වල මේ ගැන තව දුරටත් තොරතුරු තියෙනවා. ඒවත් කියවලා බලන්න. පොඩි දේවල් වලින් පටන් අරන්, ලොකු දේවල් කරන්න පුළුවන්. අභියෝගය භාරගන්නවා නේද?

මේ ගැන ඔයාලට මොනවා හරි ප්‍රශ්න තියෙනවා නම්, නැත්නම් ඔයාලා මේ ගැන තවත් දන්න දේවල් තියෙනවා නම්, පහලින් comment එකක් දාගෙනම යන්න. අනිත් අයටත් ඉගෙන ගන්න ඒක ගොඩක් වටිනවා! අපි ඊළඟ article එකෙන් හමු වෙමු! එතකල් coding වලට ජයවේවා!