Hibernate Framework - Java ORM Sinhala Tutorial | Sri Lanka

Introduction to Hibernate Framework | Sinhala Guide

කොහොමද යාලුවනේ? අද අපි කතා කරන්න යන්නේ Java development වලදී database එක්ක වැඩ කරනකොට අපේ ජීවිතේ ගොඩක් ලේසි කරගන්න පුලුවන්, හැබැයි ගොඩක් අය තාම ඒ ගැන හොඳට දන්නේ නැති වැදගත් දෙයක් ගැන – ඒ තමයි Hibernate Framework එක.

අපි දන්නවනේ, database එකක් එක්ක වැඩ කරනකොට අපිට ගොඩක් වෙලාවට SQL queries ලියන්න වෙනවා. දත්ත Save කරන්න, Update කරන්න, Delete කරන්න, Get කරන්න වගේ දේවල් වලට හැම වෙලේම JDBC API එක පාවිච්චි කරලා SQL ලියන එක ටිකක් කම්මැලි වැඩක් වගේම, ටිකක් වෙලා යන වැඩකුත් වෙනවා. සමහර වෙලාවට platform-specific SQL queries ලියන්නත් වෙනවා. මෙන්න මේ ප්‍රශ්න වලට නියම විසඳුමක් තමයි Hibernate කියන්නේ.

ඉතින්, මේ tutorial එකෙන් අපි Hibernate කියන්නේ මොකක්ද, ඒක වැඩ කරන්නේ කොහොමද, ඒකෙන් අපිට ලැබෙන වාසි මොනවද වගේම, Hibernate setup කරලා සරල application එකක් හදන හැටි පියවරෙන් පියවර බලමු. ඊට පස්සේ ඔයාලට පුළුවන් මේක ඔයාලගේ project වලටත් implement කරන්න.

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

සරලවම කිව්වොත්, Hibernate කියන්නේ Java applications වල database එක්ක වැඩ කරන්න පුදගලිකව නිර්මාණය කරපු Object-Relational Mapping (ORM) framework එකක්. "ORM" කියන එකෙන් කියවෙන්නේ අපේ Java objects (උදාහරණයක් විදියට, Student object එකක්) database එකේ tables (student table එක) වලට map කරන එකයි. ඒ කියන්නේ අපිට SQL queries ලියනවා වෙනුවට, Java objects එක්කම database operations කරන්න පුළුවන් වෙනවා.

ORM (Object-Relational Mapping) කියන්නේ මොකක්ද?

ORM කියන්නේ database එකක තියෙන දත්ත objects විදියට program එකක් ඇතුලට අරගෙන වැඩ කරන්න පුළුවන් methodology එකක්. Database එකක් relational (tables, rows, columns) වුණාට, අපි object-oriented programming (OOP) කරනකොට අපේ program එකේ තියෙන්නේ objects. මේ relational dataයි, object dataයි අතර තියෙන වෙනස (impedance mismatch) නැති කරලා, ඒ දෙක අතර පාලමක් විදියට වැඩ කරන්න තමයි ORM එකක් පාවිච්චි කරන්නේ.

Hibernate ORM එක අපිට මෙන්න මේ වගේ දේවල් කරන්න උදව් කරනවා:

• Java objects database එකට save කරන්න (insert).
• Database එකේ තියෙන records Java objects විදියට retrieve කරන්න (select).
• Java objects වල වෙනස්කම් database එකට update කරන්න (update).
• Database එකෙන් records delete කරන්න (delete).

මේ හැම දෙයක්ම වෙන්නේ අපි SQL ලියන්නේ නැතුව, සාමාන්‍ය Java code වලින් objects එක්ක වැඩ කරන විදියටමයි.

Hibernate වල වාසි

Hibernate පාවිච්චි කිරීමෙන් අපිට ලැබෙන ප්‍රධාන වාසි කිහිපයක් මෙන්න:

• Database Independence: Hibernate එක database dialect එක manage කරන නිසා අපිට විවිධ relational databases (MySQL, PostgreSQL, Oracle, SQL Server වගේ) අතර පහසුවෙන් මාරු වෙන්න පුළුවන්, SQL queries වෙනස් කරන්නේ නැතුව.
• Reduced Boilerplate Code: Database interactions වලට නිතරම ලියන්න වෙන repetitive code (JDBC connections, result set processing) අඩු කරනවා.
• Improved Productivity: SQL ලියන්න වෙන කාලය ඉතුරු වෙන නිසා, developers ලට business logic එක develop කරන්න වැඩිපුර අවධානය යොමු කරන්න පුළුවන්.
• Transaction Management: Transactions manage කරන එක Hibernate වලිනුත් පහසු කරනවා.
• Caching: Performance improve කරන්න Hibernate වලට first-level සහ second-level cache mechanism දෙකක් තියෙනවා.

Hibernate වැඩ කරන්නේ කොහොමද?

Hibernate ecosystem එකේ ප්‍රධාන components කිහිපයක් තියෙනවා. මේවා තේරුම් ගන්න එක Hibernate හරියටම පාවිච්චි කරන්න අත්‍යවශ්‍යයි.

• Entity: මේක තමයි database table එකක record එකකට අදාළව අපේ Java program එකේ තියෙන object එක. උදාහරණයක් විදියට, Student කියන Java class එකක් database එකේ student table එකට map වෙන්න පුළුවන්. මේ class එකට annotations පාවිච්චි කරලා database table එකට map කරන හැටි define කරනවා.
• Configuration: මේක තමයි Hibernate වලට අවශ්‍ය configuration details අඩංගු වෙන්නේ. Database connection settings, Hibernate dialect, mapping files (entity classes) වගේ දේවල් මේකේ තියෙනවා. මේවා hibernate.cfg.xml වගේ XML file එකකින් හෝ programmatically define කරන්න පුළුවන්.
• SessionFactory: මේක Hibernate වල main runtime interface එක. Configuration එකෙන් තමයි SessionFactory object එකක් හදන්නේ. SessionFactory එක thread-safe වගේම, application එකේ එක වතාවක් විතරක් හදන්න ඕනේ. Database connections, statements වගේ දේවල් manage කරන්නේ මේකෙන් තමයි.
• Session: මේක තමයි SessionFactory එකෙන් හදන lightweight interface එක. Session object එකක් database එකත් එක්ක වැඩ කරන්න පාවිච්චි කරනවා. Data save කරන්න, retrieve කරන්න, update කරන්න, delete කරන්න මේකෙන් පුළුවන්. Session එක thread-safe නැහැ, ඒ නිසා හැම request එකකටම අලුත් Session එකක් හදලා, වැඩේ ඉවර වුණාම close කරන්න ඕනේ.
• Transaction: Database operations commit කරන්න හෝ rollback කරන්න මේක පාවිච්චි කරනවා. හැම database operation එකක්ම transaction එකක් ඇතුලේ කරන්න ඕනේ.

Hibernate Setup එකයි, සරල උදාහරණයකුයි

හරි, දැන් අපි theoretical පැත්ත හොඳින් තේරුම් ගත්තා. දැන් අපි බලමු ප්‍රායෝගිකව Hibernate project එකක් setup කරලා, සරල database operations ටිකක් කරන හැටි. මේ උදාහරණයට අපි Maven project එකක් පාවිච්චි කරනවා වගේම, database එක විදියට MySQL පාවිච්චි කරනවා.

1. Dependencies එකතු කරගනිමු (Adding Dependencies)

මුලින්ම ඔයාලගේ pom.xml file එකට පහත dependencies ටික එකතු කරගන්න.

<dependencies>
    <!-- Hibernate Core Dependency -->
    <dependency>
        <groupId>org.hibernate</groupId>
        <artifactId>hibernate-core</artifactId>
        <version>5.6.15.Final</version> <!-- Latest stable version එක බලලා දාගන්න -->
    </dependency>

    <!-- MySQL Connector Dependency -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.33</version> <!-- Latest stable version එක බලලා දාගන්න -->
    </dependency>

    <!-- JAXB API for Java 9+ (if you are using Java 9 or higher) -->
    <!-- Hibernate 5.x needs this for XML parsing, in Java 9+ it's removed from JDK -->
    <dependency>
        <groupId>javax.xml.bind</groupId>
        <artifactId>jaxb-api</artifactId>
        <version>2.3.1</version>
    </dependency>
    <dependency>
        <groupId>org.glassfish.jaxb</groupId>
        <artifactId>jaxb-runtime</artifactId>
        <version>2.3.1</version>
    </dependency>
</dependencies>

hibernate-core කියන්නේ Hibernate වල ප්‍රධාන library එක. mysql-connector-java කියන්නේ අපේ Java application එකට MySQL database එකට connect වෙන්න අවශ්‍ය driver එක. (ඔයාලා වෙනත් database එකක් පාවිච්චි කරනවා නම්, ඒකට අදාළ connector එක දාගන්න).

2. Configuration එක හදමු (Creating Configuration)

දැන් අපි Hibernate configuration file එක හදමු. src/main/resources folder එක ඇතුලේ hibernate.cfg.xml කියලා file එකක් හදලා මේ code එක දාගන්න.

<!DOCTYPE hibernate-configuration PUBLIC
    "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">

<hibernate-configuration>
    <session-factory>
        <!-- Database connection settings -->
        <property name="hibernate.connection.driver_class">com.mysql.cj.jdbc.Driver</property>
        <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/hibernate_demo</property>
        <property name="hibernate.connection.username">root</property>
        <property name="hibernate.connection.password">your_password</property>

        <!-- SQL dialect -->
        <property name="hibernate.dialect">org.hibernate.dialect.MySQL8Dialect</property>

        <!-- Echo all executed SQL to stdout -->
        <property name="hibernate.show_sql">true</property>

        <!-- Drop and re-create the database schema on startup -->
        <!-- development වලට හොඳයි. Production වලට ddl-auto=update / validate / none පාවිච්චි කරන්න -->
        <property name="hibernate.hbm2ddl.auto">update</property>

        <!-- Mention the entity class -->
        <mapping class="com.example.hibernate.model.Student"/>
    </session-factory>
</hibernate-configuration>

මේ hibernate.cfg.xml file එකේ අපිට අවශ්‍ය database connection details, Hibernate dialect (අපි පාවිච්චි කරන database වර්ගය), වගේ දේවල් configure කරලා තියෙනවා. hibernate.hbm2ddl.auto කියන property එකෙන් කියන්නේ Hibernate වලට database schema එක auto-generate කරන්න හෝ update කරන්න පුළුවන් කියන එකයි. update කියන එකෙන් කියවෙන්නේ අපේ entity class එකේ වෙනස්කම් database එකට update කරනවා කියන එකයි (අලුත් tables හදනවා, columns add කරනවා). create-drop වගේ දැම්මොත් application එක start කරනකොට table එක create කරලා, close කරනකොට drop කරනවා (testing වලට හොඳයි).

<mapping class="com.example.hibernate.model.Student"/> එකෙන් අපි Hibernate වලට කියනවා Student කියන class එක තමයි අපේ entity එක කියලා.

ප්‍රවේශම්: ඔයාලා hibernate_demo කියලා database එකක් MySQL server එකේ හදාගන්න. username සහ password එක ඔයාලගේ database එකට අදාළව නිවැරදිව දාන්න.

3. Entity Class එක (The Entity Class)

දැන් අපි Student කියන entity class එක හදමු. මේක තමයි අපේ database එකේ student table එකට map වෙන්නේ.

package com.example.hibernate.model;

import javax.persistence.*; // JPA (Java Persistence API) annotations

@Entity // මේක Entity class එකක් බව Hibernate වලට කියනවා
@Table(name = "students") // database එකේ table එකේ නම students කියලා define කරනවා
public class Student {

    @Id // මේක primary key එක කියලා කියනවා
    @GeneratedValue(strategy = GenerationType.IDENTITY) // auto-increment primary key එකක් විදියට හදනවා
    @Column(name = "id") // database column එකේ නම id කියලා define කරනවා
    private int id;

    @Column(name = "first_name")
    private String firstName;

    @Column(name = "last_name")
    private String lastName;

    @Column(name = "email")
    private String email;

    // Default constructor (Hibernate requires a no-argument constructor)
    public Student() {
    }

    // Parameterized constructor
    public Student(String firstName, String lastName, String email) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.email = email;
    }

    // Getters and Setters
    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getFirstName() {
        return firstName;
    }

    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    @Override
    public String toString() {
        return "Student{" +
               "id=" + id +
               ", firstName='" + firstName + '\'' +
               ", lastName='" + lastName + '\'' +
               ", email='" + email + '\'' +
               '}';
    }
}

මේ Student class එකේ අපි JPA (Java Persistence API) annotations පාවිච්චි කරලා තියෙනවා Hibernate වලට මේ class එක database table එකකට map කරන හැටි කියන්න.

• @Entity: මේකෙන් කියවෙන්නේ මේ class එක database table එකකට map වෙන entity එකක් කියන එකයි.
• @Table(name = "students"): database එකේ මේ entity එකට අදාළ table එකේ නම students කියලා specify කරනවා.
• @Id: මේ field එක primary key එක කියලා specify කරනවා.
• @GeneratedValue(strategy = GenerationType.IDENTITY): primary key එක auto-increment වෙන්න ඕනේ කියලා කියනවා.
• @Column(name = "first_name"): class එකේ field එක database column එකකට map කරනවා. (field නමයි, column නමයි එකම නම් මේක අනිවාර්ය නැහැ).

4. Hibernate Utilities (HibernateUtil)

SessionFactory object එක හදන එක ටිකක් resource-heavy operation එකක්. ඒ නිසා අපි ඒක application එකේ වරක් පමණක් හදලා reuse කරනවා. ඒකට අපිට helper class එකක් හදාගන්න පුළුවන්.

package com.example.hibernate.util;

import com.example.hibernate.model.Student;
import org.hibernate.SessionFactory;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;

public class HibernateUtil {
    private static SessionFactory sessionFactory;

    public static SessionFactory getSessionFactory() {
        if (sessionFactory == null) {
            try {
                // Create Configuration object
                Configuration configuration = new Configuration();

                // Load hibernate.cfg.xml
                configuration.configure("hibernate.cfg.xml");
                configuration.addAnnotatedClass(Student.class); // Entity class එක Add කරන්න අමතක කරන්න එපා

                // Build ServiceRegistry
                ServiceRegistry serviceRegistry = new StandardServiceRegistryBuilder()
                        .applySettings(configuration.getProperties()).build();

                // Create SessionFactory
                sessionFactory = configuration.buildSessionFactory(serviceRegistry);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return sessionFactory;
    }
}

මේ HibernateUtil class එකෙන් SessionFactory object එක create කරලා return කරනවා. getSessionFactory() method එක first time call කරනකොට SessionFactory එක create කරලා, ඊට පස්සේ හැම වෙලේම තියෙන එකම object එක return කරනවා.

5. දත්ත save කරලා, retrieve කරමු (Saving and Retrieving Data)

අවසාන වශයෙන්, අපි Main class එකක් හදලා Student objects database එකට save කරලා, ආපහු retrieve කරලා බලමු.

package com.example.hibernate.app;

import com.example.hibernate.model.Student;
import com.example.hibernate.util.HibernateUtil;
import org.hibernate.Session;
import org.hibernate.Transaction;

public class Main {

    public static void main(String[] args) {

        Transaction transaction = null;
        try (Session session = HibernateUtil.getSessionFactory().openSession()) {
            // Start a transaction
            transaction = session.beginTransaction();

            // Create a Student object
            Student student1 = new Student("Nimal", "Perera", "[email protected]");
            Student student2 = new Student("Kamala", "Silva", "[email protected]");

            // Save the student objects
            session.save(student1);
            session.save(student2);

            // Commit transaction
            transaction.commit();
            System.out.println("Students saved successfully!");

            // --- Retrieve a student ---
            System.out.println("\nRetrieving a student...");
            transaction = session.beginTransaction(); // New transaction for retrieval
            Student retrievedStudent = session.get(Student.class, student1.getId());
            if (retrievedStudent != null) {
                System.out.println("Retrieved Student: " + retrievedStudent);
            } else {
                System.out.println("Student not found!");
            }
            transaction.commit(); // Commit retrieval transaction

        } catch (Exception e) {
            if (transaction != null) {
                transaction.rollback(); // Rollback if any error occurs
            }
            e.printStackTrace();
        } finally {
            // Close the SessionFactory when the application shuts down
            // In a real application, this would be managed by a server or proper shutdown hook
            // For this simple example, we'll manually close it after operations
            if (HibernateUtil.getSessionFactory() != null) {
                HibernateUtil.getSessionFactory().close();
                System.out.println("SessionFactory closed.");
            }
        }
    }
}

මේ Main class එකේ අපි කරන්නේ:

1. HibernateUtil.getSessionFactory().openSession() පාවිච්චි කරලා Session object එකක් ගන්නවා.
2. session.beginTransaction() කියලා transaction එකක් පටන් ගන්නවා.
3. Student objects හදලා, session.save() method එක පාවිච්චි කරලා database එකට save කරනවා.
4. transaction.commit() කියලා transaction එක commit කරනවා. මේකෙන් තමයි database එකට data ඇත්තටම save වෙන්නේ.
5. session.get(Student.class, student1.getId()) පාවිච්චි කරලා database එකෙන් Student object එකක් retrieve කරගන්නවා.
6. අවසානයේ SessionFactory එක close කරනවා. (සැබෑ application එකකදී මේක application server එකකින් හෝ spring framework එක වැනි dependency injection framework එකකින් manage කරනවා).

මේ program එක run කරාම ඔයාලට console එකේ Hibernate generate කරන SQL queries වගේම, අපේ output එකත් බලන්න පුළුවන්. ඒ වගේම database එකේ students table එක බලනකොට data save වෙලා තියෙනවා දකින්න පුළුවන්.

නිගමනය (Conclusion)

ඉතින් යාලුවනේ, අද අපි Hibernate Framework එක ගැන හොඳ අවබෝධයක් ලබාගත්තා. ORM කියන්නේ මොකක්ද, Hibernate වල ප්‍රධාන components මොනවද, වගේම සරලම Hibernate project එකක් setup කරලා database operations කරන හැටිත් අපි ඉගෙනගත්තා. Hibernate කියන්නේ Java applications වල database interactions වලට නියම විසඳුමක්. SQL queries ලියන්න වෙන කාලය ඉතුරු කරලා, productivity එක වැඩි කරනවා.

මේක Hibernate වල ආරම්භය විතරයි. තවත් ගොඩක් දේවල් Hibernate වල තියෙනවා (relations – One-to-One, One-to-Many, Many-to-Many, HQL, Criteria API, Caching, etc.). මේක හොඳට තේරුම් අරගෙන, ඔයාලගේම project වලට මේක implement කරලා බලන්න. එතකොට තවත් හොඳට තේරෙයි. ඒ වගේම ඔයාලා Hibernate එක්ක වැඩ කරපු අත්දැකීම්, ප්‍රශ්න, හෝ අදහස් පහතින් comment එකකින් කියන්නත් අමතක කරන්න එපා!

සතුටින් coding කරමු!