Java Application එකෙන් Database එකට යන්න, JDBC එක්ක! SC Guide

මචංලා, මේ දවස්වල Software Development ගැන කතා කරද්දී, data නැතුව වැඩක් නෑනේ! හැම Application එකකටම වගේ Database එකක් ඕන වෙනවා. Customer details, product info, user settings... මේ හැම දෙයක්ම ගබඩා වෙලා තියෙන්නෙ Database එකක. ඉතින්, අපේ Java Application එකකට මේ Database එකට ගිහින් data අරන් එන්න, data දාන්න, update කරන්න, delete කරන්න ඕන වෙනවා නේද? එතකොට තමයි JDBC (Java Database Connectivity) කියන සුපිරි Tool එක වැඩේට එන්නෙ.

අද අපි මේ ලිපියෙන් බලමු මේ JDBC කියන්නේ මොකක්ද, ඒක වැඩ කරන්නේ කොහොමද, আর අපිට ඒක අපේ project වලට කොහොමද පාවිච්චි කරන්න පුළුවන් කියල. Beginnersලට වගේම, JDBC ගැන basics ටිකක් refresh කරගන්න ඕන අයටත් මේක ගොඩක් වැදගත් වෙයි. එහෙනම්, අපි පටන් ගමු!

JDBC කියන්නේ මොකක්ද මේ මචං? (What exactly is JDBC, buddy?)

සරලව කිව්වොත්, JDBC කියන්නේ Java API (Application Programming Interface) එකක්. මේකෙන් අපිට පුළුවන් Java Application එකක් ඇතුලෙ ඉඳන්ම Database එකක් එක්ක කතා කරන්න. ඒ කියන්නේ, MySQL, PostgreSQL, Oracle, SQL Server, MongoDB වගේ මොන Database එක තිබුණත්, JDBC හරහා standardized විදිහකට ඒවට connect වෙලා data operations කරන්න පුළුවන්.

හිතන්නකෝ, ඔයාට එක එක රටවල මිනිස්සු එක්ක කතා කරන්න ඕන කියලා. හැබැයි ඔයා දන්නේ සිංහල විතරයි. එතකොට Interpreter කෙනෙක් ඕන වෙනවා නේද? JDBC කියන්නේ Java Application එකයි, Database එකයි අතර ඉන්න Interpreter වගේ දෙයක්. ඒකේ ප්‍රධාන කොටස් කිහිපයක් තියෙනවා:

• JDBC API: මේකෙන් තමයි Java Application එක Database එකත් එක්ක කතා කරන්න අවශ්‍ය classes සහ interfaces සපයන්නේ.
• JDBC Driver: මේක තමයි Database-specific කතා කරන්න පුළුවන් කොටස. ඒ කියන්නේ, MySQL වලට වෙන Driver එකක්, Oracle වලට වෙන Driver එකක් තියෙනවා. මේ Drivers තමයි Java Application එකෙන් එන requests Database එකට තේරෙන භාෂාවට හරවන්නේ.

මේකෙන් වෙන ලොකුම වාසිය තමයි, ඔයාගේ Java code එක පොඩ්ඩක්වත් වෙනස් නොකර, විවිධ Database වර්ග එක්ක වැඩ කරන්න පුළුවන් වීම.

JDBC වැඩ කරන හැටි: Basic Steps ටික (How JDBC works: The Basic Steps)

JDBC හරහා Database එකක් එක්ක වැඩ කරන්න කලින්, අපි යම්කිසි ක්‍රමවේදයක් අනුගමනය කරන්න ඕන. ප්‍රධාන පියවර 5ක් තියෙනවා:

1. Driver එක Load කරගමු! (Let's Load the Driver!)

මුලින්ම, ඔයා පාවිච්චි කරන Database එකට අදාළ JDBC Driver එක Java Virtual Machine (JVM) එකට Load කරගන්න ඕන. මේකට අපි Class.forName() method එක පාවිච්චි කරනවා.

try {
    // MySQL Driver එක Load කරනවා
    Class.forName("com.mysql.cj.jdbc.Driver"); 
    System.out.println("MySQL JDBC Driver Loaded!");
} catch (ClassNotFoundException e) {
    System.err.println("MySQL JDBC Driver Not Found! " + e.getMessage());
    // Handle exception properly in a real application
}

Tip: අලුත් JDBC versions වලදී (JDBC 4.0 ඉඳන්), Driver එක explicit විදිහට Load කරන්න ඕන වෙන්නේ නෑ. ඒත්, සමහර අවස්ථාවලදි හෝ legacy systems වලදි මේක කරන එක හොඳ පුරුද්දක්.

2. Database එකට Connect වෙමු! (Connecting to the Database!)

Driver එක Load කරගත්තට පස්සේ, අපිට Database එකට Connection එකක් හදාගන්න පුළුවන්. මේකට DriverManager.getConnection() method එක පාවිච්චි කරනවා. මෙතනදී Database URL එක, username එකයි, password එකයි දෙන්න ඕන.

Connection connection = null;
String DB_URL = "jdbc:mysql://localhost:3306/my_database";
String USER = "root";
String PASS = "my_password";

try {
    connection = DriverManager.getConnection(DB_URL, USER, PASS);
    System.out.println("Database Connected Successfully!");
} catch (SQLException e) {
    System.err.println("Connection Failed! " + e.getMessage());
    // Handle exception
}

Note: my_database, root, my_password කියන ටික ඔයාගේ Database settings අනුව වෙනස් කරගන්න ඕන.

3. Queries යවමු! (Sending Queries!)

Connection එක ලැබුණට පස්සේ, අපිට Database එකට SQL queries යවන්න පුළුවන්. මේකට ප්‍රධාන වශයෙන් Statement සහ PreparedStatement කියන interfaces දෙක පාවිච්චි කරනවා.

PreparedStatement: මේක ගොඩක් වැදගත්! Dynamic values එක්ක queries යවන්න හොඳම ක්‍රමය මේකයි. SQL Injection වළක්වා ගන්නත් පුළුවන්. Performance එකත් වැඩියි. Values replace කරන්න ? (parameter markers) පාවිච්චි කරනවා.

String sql = "INSERT INTO users (name, email) VALUES (?, ?)";
PreparedStatement preparedStatement = connection.prepareStatement(sql);
preparedStatement.setString(1, "Nimal"); // 1st '?' is for name
preparedStatement.setString(2, "[email protected]"); // 2nd '?' is for email
int rowsAffected = preparedStatement.executeUpdate();
System.out.println(rowsAffected + " row(s) inserted.");

Statement: සරල queries යවන්න. Static SQL statements වලට හොඳයි.

Statement statement = connection.createStatement();
String sql = "INSERT INTO users (name, email) VALUES ('Kamal', '[email protected]')";
int rowsAffected = statement.executeUpdate(sql); // For INSERT, UPDATE, DELETE
System.out.println(rowsAffected + " row(s) affected.");

4. Result ටික අල්ලගමු! (Getting the Results!)

SELECT queries යැව්වම අපිට Database එකෙන් data ටිකක් ලැබෙනවා. මේ data ටික අල්ලගන්න අපි ResultSet object එකක් පාවිච්චි කරනවා.

String selectSql = "SELECT id, name, email FROM users";
Statement statement = connection.createStatement();
ResultSet resultSet = statement.executeQuery(selectSql);

// Iterate through the results
while (resultSet.next()) {
    int id = resultSet.getInt("id"); // Get by column name or index (1-based)
    String name = resultSet.getString("name");
    String email = resultSet.getString("email");
    System.out.println("ID: " + id + ", Name: " + name + ", Email: " + email);
}

5. Resource ටික වහමු! (Closing Resources!)

මේක ඉතාම වැදගත් පියවරක්! Database Connection එකක් කියන්නේ මිල අධික (expensive) resource එකක්. වැඩේ ඉවර වුණාට පස්සේ, ResultSet, Statement/PreparedStatement, আর Connection object ටික පිළිවෙලට close කරන්න ඕන. එහෙම නැතුව තිබ්බොත් Memory Leaks, Connection Exhaustion වගේ ප්‍රශ්න එන්න පුළුවන්.

මේකට try-with-resources කියන feature එක පාවිච්චි කරන එක හොඳම practice එකයි. එතකොට Java ම මේ resources ටික automate විදිහට close කරනවා.

try (Connection connection = DriverManager.getConnection(DB_URL, USER, PASS);
     Statement statement = connection.createStatement();
     ResultSet resultSet = statement.executeQuery("SELECT * FROM users")) {

    // Do your database operations here
    while (resultSet.next()) {
        System.out.println(resultSet.getString("name"));
    }
    
} catch (SQLException e) {
    System.err.println("Database operation failed: " + e.getMessage());
}

මේ විදිහට `try-with-resources` පාවිච්චි කරද්දි, `connection`, `statement`, `resultSet` කියන object ටික auto close වෙනවා. ගොඩක් clean code එකක් ලිවීමටත් මේක උදව් වෙනවා.

පොඩි Practical Example එකක් බලමුද? (Shall we look at a small Practical Example?)

දැන් අපි මේ පියවර ටික එකතු කරලා, පොඩි Java Program එකක් ලියලා බලමු Database එකකට Connect වෙලා data ටිකක් Insert කරලා, ආපහු ඒ ටිකම read කරගන්න හැටි.

මේකට ඔයාගේ MySQL Database එකේ my_database කියන නමින් database එකක් හදලා, ඒක ඇතුලේ users කියන table එක හදාගන්න ඕන. ඒකේ structure එක මේ වගේ හදාගන්න පුළුවන්:

CREATE TABLE users (
    id INT AUTO_INCREMENT PRIMARY KEY,
    name VARCHAR(255) NOT NULL,
    email VARCHAR(255) NOT NULL UNIQUE
);

දැන් අපි Java code එකට යමු:

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class JdbcDemo {

    private static final String DB_URL = "jdbc:mysql://localhost:3306/my_database";
    private static final String USER = "root";
    private static final String PASS = "my_password"; // Replace with your MySQL password

    public static void main(String[] args) {

        // 1. Driver Load (Implicit in newer JDBC versions, but good to know)
        try {
            Class.forName("com.mysql.cj.jdbc.Driver");
            System.out.println("MySQL JDBC Driver Loaded.");
        } catch (ClassNotFoundException e) {
            System.err.println("Error: MySQL JDBC Driver not found! " + e.getMessage());
            return; // Exit if driver not found
        }

        // Insert Data
        insertUser("Dilshan", "[email protected]");
        insertUser("Supuni", "[email protected]");
        insertUser("Kasun", "[email protected]");

        // Read Data
        readUsers();
    }

    private static void insertUser(String name, String email) {
        String sql = "INSERT INTO users (name, email) VALUES (?, ?)";
        try (Connection conn = DriverManager.getConnection(DB_URL, USER, PASS);
             PreparedStatement pstmt = conn.prepareStatement(sql)) {

            pstmt.setString(1, name);
            pstmt.setString(2, email);

            int rowsAffected = pstmt.executeUpdate();
            System.out.println(rowsAffected + " row(s) inserted: " + name);

        } catch (SQLException e) {
            // Handle duplicate email or other SQL errors
            if (e.getErrorCode() == 1062) { // MySQL error code for duplicate entry for unique key
                System.err.println("Error: Email '" + email + "' already exists.");
            } else {
                System.err.println("Error inserting user " + name + ": " + e.getMessage());
            }
        }
    }

    private static void readUsers() {
        String sql = "SELECT id, name, email FROM users";
        System.out.println("\n--- Users in Database ---");
        try (Connection conn = DriverManager.getConnection(DB_URL, USER, PASS);
             Statement stmt = conn.createStatement();
             ResultSet rs = stmt.executeQuery(sql)) {

            while (rs.next()) {
                int id = rs.getInt("id");
                String name = rs.getString("name");
                String email = rs.getString("email");
                System.out.println("ID: " + id + ", Name: " + name + ", Email: " + email);
            }

        } catch (SQLException e) {
            System.err.println("Error reading users: " + e.getMessage());
        }
        System.out.println("-------------------------");
    }
}

මේ program එක run කරන්න කලින්, ඔයාගේ pom.xml (Maven project නම්) එකට හෝ classpath එකට MySQL Connector/J JAR file එක එකතු කරන්න අමතක කරන්න එපා. (e.g., <dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>8.0.28</version></dependency>)

වැදගත් Tips ටිකක් (Some Important Tips)

• PreparedStatement එක හැමවිටම පාවිච්චි කරන්න: Statement එකට වඩා PreparedStatement එක ආරක්ෂිතයි, වේගවත්. SQL Injection වගේ Attacks වලින් බේරෙන්න පුළුවන්.
• Error Handling (try-catch): Database operations කරද්දී SQLException කියන Exception එක එන්න පුළුවන්. ඒ නිසා හැමවිටම try-catch blocks පාවිච්චි කරලා errors handle කරන්න.
• Connection Pooling: Production Application එකකදී හැම request එකකටම අලුතින් Connection එකක් හදන එක කාර්යක්ෂම නෑ. ඒ වෙනුවට HikariCP, c3p0, Apache DBCP වගේ Connection Pooling Libraries පාවිච්චි කරන්න. ඒවයින් Connections manage කරලා performance එක වැඩි කරනවා.
• Transactions: එක දිගට database operations කිහිපයක් කරනවා නම් (උදා: බැංකු ගිණුමකින් සල්ලි අඩු කරලා, අනිත් ගිණුමට දාන එක), ඒවට Transactions පාවිච්චි කරන්න. ඒ කියන්නේ, operations සෙට් එකම සාර්ථකව ඉවර වුණොත් විතරක් commit කරන්න, නැත්නම් rollback කරන්න. connection.setAutoCommit(false);, connection.commit();, connection.rollback(); වගේ methods ඒකට පාවිච්චි කරනවා.
• Database Drivers: ඔයා පාවිච්චි කරන Database වර්ගයට අදාළ නිවැරදි Driver එක classpath එකට එකතු කරලා තියෙනවද කියලා සැමවිටම check කරන්න.

අවසන් වශයෙන්... (Finally...)

ඔන්න මචංලා, අපි Java Database Connectivity (JDBC) ගැන හොඳ Introduction එකක් බැලුවා. Database එකක් එක්ක Java Application එකකින් වැඩ කරන්න JDBC කියන්නේ කොයි තරම් වැදගත් දෙයක්ද කියලා දැන් ඔයාලට තේරෙනවා ඇති. Backend Development වලදී මේ දැනුම ඔයාලට අනිවාර්යයෙන්ම ඕන වෙනවා.

මේක අත්දැකලා බලන්න හොඳම ක්‍රමය තමයි ඔයාලගේම පොඩි project එකක් පටන් අරන්, මේ concepts ටික apply කරන එක. පොඩි Console Application එකක් හරි වෙන්න පුළුවන්. මොනවා හරි ප්‍රශ්න තියෙනවා නම්, Code එකේ අවුලක් ආවොත්, එහෙම නැත්නම් මේ ලිපිය ගැන ඔයාලගේ අදහස් දැනගන්න කැමතියි. පහතින් Comment එකක් දාලා යන්න අමතක කරන්න එපා!

ඊළඟ ලිපියෙන් තවත් මෙවැනිම වැදගත් තොරතුරු අරගෙන එන්නම්! ඒ වනතුරු Code කර කර ඉන්න!