මාතෘකාව 4: දත්ත සමුදාය ඒකාබද්ධ කිරීම - දත්ත වලට ජීවය දීම

4.1 දත්ත සමුදාය (Database) හැඳින්වීම

මේ වන තෙක් අපගේ යෙදුම හැසිරවූ ඕනෑම දත්තයක් තාවකාලිකයි—අපි යෙදුම නැවැත්වූ මොහොතේම එය අතුරුදහන් වේ. දත්ත ස්ථිරව ගබඩා කිරීම සඳහා, අපට දත්ත සමුදායක් අවශ්‍ය වේ. අපි සම්බන්ධතා දත්ත සමුදායක් (relational database) භාවිතා කරන්නෙමු, එහිදී දත්ත වගු (tables) වල පේළි (rows) සහ තීරු (columns) ලෙස සංවිධානය කර ඇත.

• MySQL / PostgreSQL: මේවා නිෂ්පාදන මට්ටමේ (production) යෙදුම් සඳහා ඉතා සුදුසු, බලවත්, කර්මාන්ත-ප්‍රමිතියෙන් යුතු විවෘත මූලාශ්‍ර දත්ත සමුදායන් වේ.
• H2 Database: මෙය Java වලින් ලියන ලද, සැහැල්ලු, in-memory දත්ත සමුදායකි. සංවර්ධන කටයුතු සඳහා එය ඉතා පහසු වන්නේ එයට වෙනම ස්ථාපනයක් අවශ්‍ය නොවන නිසාත්, ඔබගේ Spring Boot යෙදුම සමඟම ආරම්භ කර නැවැත්විය හැකි නිසාත් ය. මෙම පාඨමාලාවේදී, දේවල් සරලව තබා ගැනීම සඳහා අපි H2 දත්ත සමුදාය භාවිතා කරන්නෙමු.

4.2 Spring Boot සමග දත්ත සමුදායක් සම්බන්ධ කිරීම (JPA + Hibernate)

අපගේ Java objects (Account object එකක් වැනි) දත්ත සමුදා වගුවකට ඇතුළත් කරන්නේ කෙසේද? පැරණි ක්‍රමය වූයේ JDBC නම් තාක්‍ෂණය භාවිතයෙන් අතින් SQL කේත රාශියක් ලිවීමයි. මෙය වෙහෙසකර මෙන්ම දෝෂ ඇතිවීමට වැඩි ඉඩක් ඇති ක්‍රමයක් විය.

නවීන විසඳුම වන්නේ ORM (Object-Relational Mapping) ය.

JPA (Java Persistence API)

උපමාව: කාර් එකේ Dashboard එක. JPA යනු පිරිවිතරයකි (specification), නිෂ්පාදනයක් නොවේ. එය සම්මත නීති මාලාවක් සහ interfaces සමූහයකි. සෑම කාර් dashboard එකකම වේග මාපකයක්, ඉන්ධන මිනුමක් ඇත. ඒ ආකාරයට, JPA මගින් objects `save()`, `find()`, සහ `delete()` කිරීමට ක්‍රම අවශ්‍ය බව නිර්වචනය කරයි, නමුත් එය සැබෑ කාර්යය නොකරයි.

Hibernate

උපමාව: එන්ජිම. Hibernate යනු JPA පිරිවිතරයේ වඩාත්ම ජනප්‍රිය ක්‍රියාත්මක කිරීමයි (implementation). එය JPA "dashboard" එක කියවා, ඔබගේ Java objects SQL විමසුම් (queries) බවට පරිවර්තනය කර දත්ත සමුදායේ සුරැකීමේ සැබෑ කාර්යය කරන බලවත් එන්ජිමයි.

Spring Data JPA

උපමාව: Automatic Transmission එක. Spring Data JPA මගින් JPA සහ Hibernate භාවිතා කිරීම ඇදහිය නොහැකි තරම් පහසු කරයි. එය ඉහළින් ඇති තවත් ස්ථරයක් වන අතර, "repository" interfaces සපයයි. හුදෙක් interface එකක් නිර්මාණය කිරීමෙන්, Spring Data JPA විසින් සියලුම සම්මත CRUD (Create, Read, Update, Delete) මෙහෙයුම් සඳහා සම්පූර්ණ ක්‍රියාත්මක කිරීමක් ස්වයංක්‍රීයව සපයයි. ඔබට කිසිදු boilerplate කේතයක් ලිවීමකින් තොරව සම්පූර්ණ බලය ලැබේ.

4.3 Account සහ Customer Entities නිර්මාණය කිරීම

Entity යනු දත්ත සමුදා වගුවකට map කර ඇති සරල Java class එකකි. මෙම mapping එක Hibernate වෙත පවසන ආකාරය සඳහා අපි විශේෂ JPA annotations භාවිතා කරමු.

අපි අපගේ පළමු entity එක, `Account.java` නිර්මාණය කරමු.

import jakarta.persistence.*;

@Entity // 1. මෙම class එක දත්ත සමුදායේ table එකක් ලෙස සලකුණු කරයි
@Table(name = "accounts") // 2. (වෛකල්පිත) table එකේ නම නියම කරයි
public class Account {

    @Id // 3. මෙම field එක ප්‍රාථමික යතුර (primary key) ලෙස සලකුණු කරයි
    @GeneratedValue(strategy = GenerationType.IDENTITY) // 4. ID එක ස්වයංක්‍රීයව වැඩි කරයි
    private Long id;

    @Column(name = "account_holder_name", nullable = false) // 5. column එකකට map කරයි, හිස් විය නොහැක
    private String accountHolderName;

    @Column(nullable = false)
    private double balance;
    
    // Constructors, Getters, සහ Setters JPA සඳහා අවශ්‍ය වේ.
}

1. @Entity: වැදගත්ම annotation එක. මෙම class එක table එකක් නියෝජනය කරන බව Spring Data JPA වෙත පවසයි.
2. @Id: සෑම වගුවකටම සෑම පේළියක්ම අනන්‍ය ලෙස හඳුනා ගැනීමට ප්‍රාථමික යතුරක් අවශ්‍ය වේ.
3. @GeneratedValue: ID එක අප වෙනුවෙන් කළමනාකරණය කරන ලෙස අපි දත්ත සමුදායට පවසමු.
4. @Column: column mapping එකේ නම හෝ එය null විය හැකිද යන්න වැනි දේ අභිරුචිකරණය කිරීමට අපට ඉඩ සලසයි.

4.4 Spring Data JPA සමඟ Repository Layer එක

මෙතන තමයි මැජික් එක වෙන්නේ. අපි class එකක් ලියන්නේ නැහැ; අපි ලියන්නේ interface එකක්. Spring Data JPA විසින් runtime එකේදී අප වෙනුවෙන් ක්‍රියාත්මක කිරීමක් ස්වයංක්‍රීයව සාදනු ඇත.

AccountRepository.java නමින් නව interface එකක් සාදන්න.

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface AccountRepository extends JpaRepository<Account, Long> {
    // එච්චරයි! වෙන කිසිම දෙයක් ලියන්න අවශ්‍ය නැහැ.
}

4.5 CRUD මෙහෙයුම් ලිවීම

දැන්, අපි අපගේ දත්ත සමුදායට නව ගිණුමක් සුරැකිය හැකි API endpoint එකක් සෑදීමට සියල්ල එකට සම්බන්ධ කරමු.

පියවර 1: Dependencies සහ Configuration එක් කිරීම

ඔබගේ pom.xml ගොනුවේ, මෙම dependencies ඇති බවට වග බලා ගන්න:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
    <groupId>com.h2database</groupId>
    <artifactId>h2</artifactId>
    <scope>runtime</scope>
</dependency>

src/main/resources/application.properties හි, අපගේ H2 දත්ත සමුදාය configure කිරීමට මෙම පේළි එක් කරන්න:

# H2 Database Settings
spring.datasource.url=jdbc:h2:mem:bankdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=password
spring.h2.console.enabled=true

# JPA/Hibernate Settings
spring.jpa.hibernate.ddl-auto=update

පියවර 2: Service සහ Controller නිර්මාණය කිරීම

// --- AccountService.java ---
@Service // මෙය service component එකක් ලෙස සලකුණු කරයි
public class AccountService {
    @Autowired // Spring මගින් AccountRepository instance එක ස්වයංක්‍රීයව inject කරයි
    private AccountRepository accountRepository;

    public Account createAccount(Account account) {
        return accountRepository.save(account);
    }
}

// --- AccountController.java ---
@RestController
@RequestMapping("/api/accounts")
public class AccountController {
    @Autowired
    private AccountService accountService;

    // නව ගිණුමක් සාදන්න
    @PostMapping
    public Account createAccount(@RequestBody Account account) {
        return accountService.createAccount(account);
    }
}

දැන්, ඔබ ඔබගේ යෙදුම ධාවනය කර http://localhost:8080/api/accounts වෙත { "accountHolderName": "Nimal Silva", "balance": 500.0 } වැනි JSON body එකක් සමඟ POST ඉල්ලීමක් යැවූ විට, ගිණුම සාර්ථකව දත්ත සමුදායේ සුරැකී, ID එකක් සමඟින් ඔබට ප්‍රතිචාරයක් ලෙස ලැබෙනු ඇත!