Hibernate Setup Java Project Sinhala | Dependencies & hibernate.cfg.xml Configuration Guide

ආයුබෝවන් හැමෝටම! Java project එකක Hibernate Setup කරගමු!

අද කාලේ software development වලදී, database එක්ක වැඩ කරනවා කියන්නේ හැම project එකකම වගේ අත්‍යවශ්‍ය දෙයක්. ඒ වගේම ඒක පහසුවෙන්, කාර්යක්ෂමව කරගන්න එකත් ගොඩක් වැදගත්. Java developer කෙනෙක් විදියට ඔයාට මේ දේට හොඳම solution එකක් තමයි Hibernate කියන්නේ. අද අපි කතා කරන්නේ Java project එකක Hibernate configure කරගන්නේ කොහොමද, ඒකට අවශ්‍ය dependencies මොනවද, සහ ප්‍රධානම configuration file එක වන hibernate.cfg.xml එක හදාගන්නේ කොහොමද කියන එක ගැනයි.

SQL queries ලියලා, JDBC boilerplate code ගොඩක් ලියලා database operations කරනවා කියන්නේ කාලය නාස්ති වෙන, ඒ වගේම වැරදි වෙන්න තියෙන ඉඩකඩ වැඩි දෙයක්. Hibernate වගේ ORM (Object-Relational Mapping) framework එකක් පාවිච්චි කරන එකෙන් අපිට පුළුවන් Java objects විදියටම data එක්ක වැඩ කරන්න. ඒකෙන් code එක clear වෙනවා වගේම, developer productivity එකත් වැඩි වෙනවා. පහසුයි නේද?

මේ tutorial එකෙන් අපි පියවරෙන් පියවර Hibernate setup කරන විදිය ගැන ඉගෙන ගමු. එහෙනම්, වැඩේට බහිමු!

1. Hibernate කියන්නේ මොකක්ද සහ ඇයි අපි ඒක පාවිච්චි කරන්නේ?

සරලවම කිව්වොත්, Hibernate කියන්නේ Java programming language එකට තියෙන ORM (Object-Relational Mapping) framework එකක්. මේකෙන් වෙන්නේ Java objects සහ relational database tables අතර mapping එකක් හදන එකයි. ඒ කියන්නේ, ඔයාට database එකේ තියෙන data, Java objects විදියට program එක ඇතුළේ පාවිච්චි කරන්න පුළුවන්. ඒ වගේම Java objects database එකට save කරන්නත් පුළුවන්.

ORM වලින් ලැබෙන වාසි:

• සරල බව (Simplicity): SQL queries ලියන එකෙන් මිදිලා Java objects විදියට data එක්ක වැඩ කරන්න පුළුවන්.
• Productivity වැඩිවීම: Boilerplate code ලියන එක අඩු වෙන නිසා project එකක් ඉක්මනින් develop කරන්න පුළුවන්.
• Database ස්වාධීනත්වය (Database Independence): ඔයාට database එකක් මාරු කරන්න අවශ්‍ය වුණොත්, code එකේ ලොකු වෙනසක් කරන්න ඕනේ නැහැ. Hibernate ඒක handle කරනවා.
• Cache කිරීමේ හැකියාව (Caching): Hibernate එකේ First-level සහ Second-level caching mechanisms තියෙනවා. මේකෙන් database access කරන වාර ගණන අඩු කරලා application performance එක වැඩි කරන්න පුළුවන්.
• Transaction Management: Database transactions පහසුවෙන් manage කරන්න පුළුවන්.

දැන් ඔයාලට තේරෙනවා ඇති Hibernate කියන්නේ කොච්චර වටින දෙයක්ද කියලා. අපි දැන් බලමු මේක අපේ project එකට එකතු කරගන්නේ කොහොමද කියලා.

2. අවශ්‍ය Dependencies එකතු කරගැනීම (Adding Necessary Dependencies)

අපේ Java project එකට Hibernate පාවිච්චි කරන්න නම්, මුලින්ම ඒකට අවශ්‍ය libraries (dependencies) එකතු කරගන්න ඕනේ. අපි මේකට Apache Maven Build Tool එක පාවිච්චි කරමු. ඔයා Gradle වගේ වෙනත් build tool එකක් පාවිච්චි කරනවා නම්, ඒකට අදාළ dependencies එකතු කරන්න පුළුවන්.

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

pom.xml Dependencies:

<dependencies>

    <!-- Hibernate Core Dependency -->
    <dependency>
        <groupId>org.hibernate.orm</groupId>
        <artifactId>hibernate-core</artifactId>
        <version>6.2.7.Final</version> <!-- නවතම stable version එකක් භාවිතා කරන්න -->
    </dependency>

    <!-- Database Connector Dependency (උදාහරණයක් ලෙස MySQL) -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.33</version> <!-- ඔයාගේ database එකට අදාළ connector version එක -->
    </dependency>

    <!-- H2 Database (Test කිරීම් සඳහා පහසුයි) -->
    <dependency>
        <groupId>com.h2database</groupId>
        <artifactId>h2</artifactId>
        <version>2.2.220</version> <!-- H2 version එක -->
        <scope>test</scope>
    </dependency>

    <!-- Jakarta Persistence API (Hibernate 6+ සඳහා) -->
    <dependency>
        <groupId>jakarta.persistence</groupId>
        <artifactId>jakarta.persistence-api</artifactId>
        <version>3.1.0</version> <!-- නවතම stable version එකක් භාවිතා කරන්න -->
    </dependency>

</dependencies>

මේ pom.xml snippet එකෙන් අපි ප්‍රධාන dependencies ටික එකතු කරලා තියෙනවා:

• hibernate-core: මේක තමයි Hibernate framework එකේ ප්‍රධාන library එක. Hibernate වල සියලුම core functionalities මේකෙන් ලැබෙනවා.
• mysql-connector-java: අපි MySQL database එකක් පාවිච්චි කරනවා නම්, මේ connector එක අත්‍යවශ්‍යයි. ඔයා PostgreSQL, Oracle වගේ වෙනත් database එකක් පාවිච්චි කරනවා නම්, ඒකට අදාළ connector එක එකතු කරන්න ඕනේ.
• h2: මේක In-Memory database එකක්. Test කිරීම් සඳහා සහ ඉක්මන් proof-of-concept projects වලට ඉතාමත් පහසුයි. මම මේක scope එක test විදියට දාලා තියෙන්නේ, production වලට වඩා test කිරීම් වලදී ප්‍රයෝජනවත් වෙන නිසා.
• jakarta.persistence-api: Hibernate 6 සහ ඊට ඉහළ versions වලදී JPA (Java Persistence API) implement කරන්න මේ dependency එක අවශ්‍ය වෙනවා.

Dependencies එකතු කරාට පස්සේ, ඔයාගේ IDE එකෙන් (IntelliJ IDEA, Eclipse) Maven project එක update කරන්න. එතකොට අවශ්‍ය libraries download වෙලා project එකට එකතු වෙයි.

3. hibernate.cfg.xml ගොනුව සකස් කරගැනීම (Configuring hibernate.cfg.xml)

දැන් අපි බලමු Hibernate වලට database එකත් එක්ක connect වෙන්න සහ වැඩ කරන්න අවශ්‍ය විස්තර ටික hibernate.cfg.xml කියන XML file එකේ configure කරගන්නේ කොහොමද කියලා.

මේ file එක සාමාන්‍යයෙන් ඔයාගේ project එකේ src/main/resources folder එක ඇතුළේ තියෙන්න ඕනේ. ඒක තමයි classpath එකේ Hibernate එකට මේ file එක හොයාගන්න පුළුවන් ප්‍රධානම තැන.

hibernate.cfg.xml උදාහරණය:

<?xml version="1.0" encoding="UTF-8"?>
<!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/your_database_name?useSSL=false&amp;serverTimezone=UTC</property>
        <property name="hibernate.connection.username">root</property>
        <property name="hibernate.connection.password">your_password</property>
        <property name="hibernate.connection.pool_size">1</property>

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

        <!-- Schema Export Settings -->
        <property name="hibernate.hbm2ddl.auto">update</property> <!-- create | create-drop | update | validate | none -->

        <!-- SQL Logging Settings -->
        <property name="hibernate.show_sql">true</property> <!-- Console එකේ SQL queries පෙන්වන්න -->
        <property name="hibernate.format_sql">true</property> <!-- Console එකේ SQL queries format කරන්න -->

        <!-- Current Session Context Class -->
        <property name="hibernate.current_session_context_class">thread</property>

        <!-- Mapping Resources -->
        <!-- <mapping class="com.example.myapp.model.Student"/> -->
        <!-- <mapping resource="com/example/myapp/model/Student.hbm.xml"/> -->

    </session-factory>
</hibernate-configuration>

හරි, දැන් අපි මේ configuration properties එකින් එක තේරුම් ගමු:

• hibernate.connection.driver_class: මේකෙන් කියවෙන්නේ database එකට connect වෙන්න පාවිච්චි කරන JDBC driver එක. MySQL නම් com.mysql.cj.jdbc.Driver.
• hibernate.connection.url: Database එකට connect වෙන URL එක. your_database_name වෙනුවට ඔයාගේ database නම සහ localhost:3306 වෙනුවට database server එකේ IP address/port එක දෙන්න. useSSL=false සහ serverTimezone=UTC වගේ දේවල් MySQL වලදී වැදගත් වෙනවා.
• hibernate.connection.username: Database එකට log වෙන්න පාවිච්චි කරන user name එක.
• hibernate.connection.password: අදාළ user name එකේ password එක.
• hibernate.dialect: මේකෙන් Hibernate එකට කියනවා අපි පාවිච්චි කරන්නේ මොන වගේ database එකක්ද කියලා. ඒ අනුව Hibernate එක අදාළ SQL queries generate කරනවා. MySQL 8 නම් org.hibernate.dialect.MySQL8Dialect.
• hibernate.hbm2ddl.auto: මේක ගොඩක් වැදගත් property එකක්! මේකෙන් Hibernate එකට කියනවා application එක start වෙනකොට database schema එකට මොනවද කරන්න ඕනේ කියලා. මේකට දාන්න පුළුවන් values කීපයක් තියෙනවා:
  • create: හැමදාම application එක start වෙනකොට database එකේ tables delete කරලා අලුතින් හදනවා. Test කිරීම් වලදී හොඳයි, production වලට නුසුදුසුයි.
  • create-drop: create වගේමයි, හැබැයි application එක shutdown වෙනකොට tables delete කරනවා. Test කිරීම් වලට හොඳයි.
  • update: මේකෙන් වෙන්නේ database schema එකේ වෙනස්කම් තියෙනවා නම්, ඒ වෙනස්කම් විතරක් update කරන එකයි. Tables delete කරන්නේ නැහැ, data වලට හානියක් වෙන්නේ නැහැ. Production වලට ගොඩක් වෙලාවට මේක තමයි පාවිච්චි කරන්නේ.
  • validate: Hibernate එක database schema එක validate කරනවා. Code එකේ තියෙන entities එක්ක database එකේ tables match වෙනවද කියලා බලනවා. වෙනසක් තියෙනවා නම් error එකක් දෙනවා.
  • none: කිසිම දෙයක් කරන්නේ නැහැ. Database schema එක අපි manualy manage කරනවා නම් මේක පාවිච්චි කරන්න පුළුවන්.
• hibernate.show_sql: මේක true කරාම, Hibernate එකෙන් generate කරන හැම SQL query එකක්ම console එකේ print කරනවා. Debug කිරීම් වලට ගොඩක් ප්‍රයෝජනවත්!
• hibernate.format_sql: true කරාම, console එකේ print කරන SQL queries ලස්සනට format කරලා පෙන්නනවා.
• hibernate.current_session_context_class: thread කියන value එක දානවා නම්, Hibernate එක current session එක manage කරන්නේ thread එකකට අදාළව.
• <mapping class="..."/>: මෙතනට තමයි අපි database එකට map කරන්න බලාපොරොත්තු වෙන Java entity classes ටික එකතු කරන්නේ. අපි ඊළඟ section එකේදී ඒ ගැන කතා කරමු.

මතක තියාගන්න, ඔයාගේ database credentials සහ database name එක නිවැරදිව දෙන්න ඕනේ. නැත්නම් connect වෙද්දී error එන්න පුළුවන්.

4. Entity Class එකක් සහ Mapping එකක් (An Entity Class and its Mapping)

දැන් අපි බලමු Java object එකක් database table එකකට map කරන්නේ කොහොමද කියලා. අපි මේකට Student කියන සරල entity එකක් හදාගමු.

Student.java Entity Class එක:

package com.example.hibernateapp.model;

import jakarta.persistence.*; // Hibernate 6+ නම් jakarta.persistence.annotations

@Entity // මේ class එක database table එකකට map වෙනවා කියන එකට
@Table(name = "students") // database එකේ table නම "students" විදියට තියෙනවා කියන එකට
public class Student {

    @Id // මේ field එක Primary Key එක කියන එකට
    @GeneratedValue(strategy = GenerationType.IDENTITY) // ID එක database එකෙන් auto generate වෙනවා කියන එකට
    @Column(name = "id") // database එකේ column නම "id" කියන එකට
    private int id;

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

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

    // Default Constructor (අවශ්‍යයි)
    public Student() {
    }

    // Constructor with fields
    public Student(String name, String email) {
        this.name = name;
        this.email = email;
    }

    // Getters and Setters (අවශ්‍යයි)
    public int getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getEmail() {
        return email;
    }

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

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

මේ Student class එකේ අපි JPA annotations පාවිච්චි කරලා තියෙනවා. මේවා තමයි Hibernate එකට කියන්නේ මේ class එක database table එකකට map කරන්නේ කොහොමද කියලා.

• @Entity: මේකෙන් කියන්නේ මේ Java class එක database එකේ table එකක් නියෝජනය කරනවා කියන එකයි.
• @Table(name = "students"): මේකෙන් අපි database එකේ table එකේ නම students කියලා specify කරනවා. මේ annotation එක නැතිනම්, Hibernate එක class එකේ නම (Student) table නම විදියට පාවිච්චි කරනවා.
• @Id: මේකෙන් කියන්නේ මේ field එක (id) database table එකේ primary key එක කියන එකයි.
• @GeneratedValue(strategy = GenerationType.IDENTITY): මේකෙන් කියන්නේ id එකේ අගය database එක විසින්ම auto increment කරලා generate කරනවා කියන එකයි. GenerationType එකට තව values තියෙනවා (AUTO, SEQUENCE, TABLE).
• @Column(name = "name"): මේකෙන් අපි Java field එකක් (name) database table එකේ column එකකට (name) map කරනවා. මේ annotation එක නැතිනම්, Hibernate එක field එකේ නම column නම විදියට පාවිච්චි කරනවා.

දැන් අපි හදපු Student entity එක ගැන Hibernate එකට කියන්න ඕනේ. ඒකට hibernate.cfg.xml file එකේ <session-factory> tag එක ඇතුළට මේ line එක එකතු කරන්න:

<!-- Mapping Resources -->
<mapping class="com.example.hibernateapp.model.Student"/>

ඔයාගේ Student.java class එකේ package path එක නිවැරදිව දෙන්න ඕනේ.

5. Hibernate SessionFactory එකක් හදාගැනීම සහ Test කිරීම (Creating a Hibernate SessionFactory and Testing)

Hibernate එක්ක වැඩ කරන්න නම්, අපිට මුලින්ම SessionFactory එකක් අවශ්‍ය වෙනවා. SessionFactory කියන්නේ thread-safe object එකක්. මේකෙන් Session objects හදන්න පුළුවන්. Session object එක තමයි database operations කරන්න පාවිච්චි කරන්නේ.

Hibernate Util Class එකක්:

සාමාන්‍යයෙන් SessionFactory එක application එකේ ජීවිත කාලය පුරාවටම තියෙන්න ඕනේ නිසා, අපි ඒක initialize කරගන්න utility class එකක් හදාගමු. මේක Singleton pattern එකක් පාවිච්චි කරලා හදාගන්න පුළුවන්.

package com.example.hibernateapp.util;

import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public class HibernateUtil {

    private static SessionFactory sessionFactory;

    public static SessionFactory getSessionFactory() {
        if (sessionFactory == null) {
            try {
                // hibernate.cfg.xml file එක load කරනවා
                Configuration configuration = new Configuration().configure("hibernate.cfg.xml");

                // SessionFactory එක build කරනවා
                sessionFactory = configuration.buildSessionFactory();

            } catch (Exception e) {
                e.printStackTrace();
                System.out.println("SessionFactory initialization failed: " + e.getMessage());
                throw new ExceptionInInitializerError(e);
            }
        }
        return sessionFactory;
    }

    public static void shutdown() {
        // application එක shutdown වෙනකොට SessionFactory එක close කරන්න.
        if (sessionFactory != null && !sessionFactory.isClosed()) {
            sessionFactory.close();
        }
    }
}

Test කිරීම: Student කෙනෙක්ව database එකට save කරමු!

දැන් අපි හදපු Hibernate setup එක වැඩ කරනවද කියලා බලන්න, main method එකක් තියෙන class එකක් හදලා Student object එකක් save කරලා බලමු.

package com.example.hibernateapp;

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

public class App {
    public static void main(String[] args) {

        Transaction transaction = null;
        try (Session session = HibernateUtil.getSessionFactory().openSession()) {
            // transaction එක පටන් ගන්නවා
            transaction = session.beginTransaction();

            // අලුත් Student object එකක් හදනවා
            Student student1 = new Student("Kasun Silva", "[email protected]");
            Student student2 = new Student("Nimal Perera", "[email protected]");

            // Student object database එකට save කරනවා
            session.persist(student1);
            session.persist(student2);
            System.out.println("Students saved: " + student1 + ", " + student2);

            // transaction එක commit කරනවා
            transaction.commit();

        } catch (Exception e) {
            if (transaction != null) {
                transaction.rollback(); // error එකක් ආවොත් rollback කරනවා
            }
            e.printStackTrace();
            System.out.println("Error saving students: " + e.getMessage());
        } finally {
            HibernateUtil.shutdown(); // SessionFactory එක close කරනවා
        }

        // Test Read Operation (Optional)
        try (Session session = HibernateUtil.getSessionFactory().openSession()) {
            Student retrievedStudent = session.get(Student.class, 1);
            if (retrievedStudent != null) {
                System.out.println("Retrieved Student: " + retrievedStudent);
            } else {
                System.out.println("Student with ID 1 not found.");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

මේ App.java class එක run කරාම, Hibernate එක ඔයාගේ database එකට connect වෙලා students කියලා table එකක් හදලා (ඔයා hbm2ddl.auto එක update හෝ create දාලා තියෙනවා නම්), Kasun Silva සහ Nimal Perera කියන students ලා දෙන්නා database එකට save වෙයි. Console එකේ SQL queries පේනවා නම්, ඔයාගේ setup එක සාර්ථකයි!

මෙහිදී session.persist(object) කියන්නේ Hibernate 5+ වලදී object එකක් database එකට save කරන්න පාවිච්චි කරන method එක. කලින් session.save(object) පාවිච්චි කළා. session.get(Class, id) කියන්නේ ID එකක් දීලා object එකක් database එකෙන් load කරගන්න. try-with-resources statement එක පාවිච්චි කරලා තියෙන්නේ Session object එක automatically close කරන්න.

නිගමනය (Conclusion)

අද අපි Java project එකක Hibernate configure කරගන්න විදිය, ඒකට අවශ්‍ය dependencies එකතු කරන විදිය, ප්‍රධාන configuration file එක වන hibernate.cfg.xml එක සකස් කරන විදිය, Entity class එකක් හදාගන්න විදිය, ඒ වගේම Hibernate SessionFactory එකක් පාවිච්චි කරලා database එකට data save කරන විදිය ගැන ඉගෙන ගත්තා. මේක ඔයාගේ Java application වල data persistence manage කරන්න අත්‍යාවශ්‍ය දැනුමක්. දැන් ඔයාට පුළුවන් Hibernate වල තියෙන බලය පාවිච්චි කරලා, database interactions සරල කරගන්න.

මේකෙන් ඔයාලට Hibernate ගැන හොඳ අවබෝධයක් ලැබෙන්න ඇති කියලා මම හිතනවා. මතක තියාගන්න, මෙතනින් නවතින්න එපා! Hibernate වලට තව ගොඩක් දේවල් තියෙනවා ඉගෙන ගන්න. Relationships (One-to-Many, Many-to-Many), advanced queries (HQL, Criteria API) වගේ දේවල් ගැනත් හොයලා බලන්න. ඒ වගේම Spring Boot වගේ framework එකක් එක්ක Hibernate integrate කරන විදිය ගැනත් ඉගෙන ගන්න. එතකොට Hibernate setup කරන එක තවත් පහසු වෙනවා.

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