JSP Scripting Elements (Scriptlets, Expressions, Declarations) සිංහලෙන් - SC Guide

ආයුබෝවන් යාලුවනේ! කොහොමද ඔයාලට? අද අපි කතා කරන්න යන්නේ Java Web Development වලදී නැතුවම බැරි, ඒ වගේම ගොඩක් දෙනෙක්ට ටිකක් පැටලෙනවා වගේ දැනෙන Subject එකක් ගැන. ඒ තමයි JSP (JavaServer Pages). විශේෂයෙන්ම අපි බලමු JSP වල තියෙන scripting elements ගැන - ඒ කියන්නේ Scriptlets, Expressions, සහ Declarations කියන තුන්කට්ටුව ගැන. මේවා මොකටද, කොහොමද පාවිච්චි කරන්නේ කියලා පැහැදිලිව තේරුම් ගත්තොත්, ඔයාලට Dynamic Web Pages හදන එක ලේසියි වගේම ගොඩක් powerful වෙනවා. අපි එහෙනම් මේ ගැඹුරු Subject එක සරලව තේරුම් ගනිමු!

JSP කියන්නේ මොකද්ද? (What is JSP?)

සරලවම කිව්වොත්, JSP කියන්නේ HTML, XML, නැත්නම් වෙනත් Document Types එක්ක Java Code එක එකට මිශ්‍ර කරලා Dynamic Web Pages හදන්න පුළුවන් තාක්ෂණයක්. ඔයාලා දන්නවා ඇති, සාමාන්‍ය HTML Pages හැම වෙලාවෙම එකම content එකක් තමයි පෙන්නන්නේ. ඒත් අපිට database එකකින් data අරගෙන පෙන්නන්න, user input එකක් අරගෙන ඒ අනුව page එක වෙනස් කරන්න වගේ දේවල් ඕන වෙනවානේ. ඔන්න ඕකට තමයි JSP අපිට උදව් කරන්නේ.

JSP file එකක් (ඒ කියන්නේ .jsp extension එකෙන් ඉවර වෙන file එකක්) Server එකට request එකක් ආවම, Server එක විසින් ඒක Servlet එකක් බවට Convert කරලා Compile කරනවා. ඊට පස්සේ ඒ Compile කරපු Servlet එක Execute කරලා එන HTML Output එක තමයි Client ගේ Browser එකට යවන්නේ. මේ ක්‍රියාවලිය සිදුවන්නේ Server side එකේදී. මේ නිසා, Client side එකට යන්නේ සාමාන්‍ය HTML විතරයි. එහෙනම් අපි බලමු මේ Java Code එක HTML එක්ක මිශ්‍ර කරන්නේ කොහොමද කියලා.

අපේ Scripting තුන්කට්ටුව (The Scripting Trio)

JSP වල ප්‍රධාන වශයෙන්ම Scripting elements වර්ග තුනක් තියෙනවා. ඒවා තමයි:

1. Scriptlets (<% ... %>)
2. Expressions (<%= ... %>)
3. Declarations (<%! ... %>)

අපි මේ එකින් එක ගැඹුරින් බලමු.

1. Scriptlets (<% ... %>)

මුලින්ම බලමු Scriptlets ගැන. මේවා පාවිච්චි කරන්නේ සාමාන්‍ය Java Code block එකක් JSP Page එකක් ඇතුලට ලියන්න. මේක හරියට Servlet එකක _jspService() method එක ඇතුලේ Java code ලියනවා වගේ දෙයක්. Variables declare කරන්න, Loops පාවිච්චි කරන්න, Conditionals (if/else) දාන්න, Database Operations කරන්න, Methods call කරන්න වගේ ගොඩක් දේවල් වලට මේක ප්‍රයෝජනවත් වෙනවා.

Scriptlet එකක් ඇතුලේ තියෙන code එක Servlet එකේ service() method එක ඇතුලටම generate වෙන නිසා, ඔබට request, response, session, out වගේ implicit objects වලට කෙලින්ම access කරන්න පුළුවන්.

උදාහරණ:

<%-- Scriptlet Example 1 --%>
<h2>සුබ පැතුම් පණිවිඩය</h2>
<% 
    String userName = "සඳුන්"; // Java variable declaration
    out.println("<p>ආයුබෝවන්, " + userName + "!</p>"); // Printing HTML using out.println()
    
    // Get current hour to display a time-based greeting
    int hour = new java.util.Date().getHours();
    if (hour < 12) {
        out.println("<p>සුබ උදෑසනක්!</p>");
    } else if (hour < 18) {
        out.println("<p>සුබ දහවලක්!</p>");
    } else {
        out.println("<p>සුබ සන්ධ්‍යාවක්!</p>");
    }
%>

<%-- Scriptlet Example 2: Looping through a list --%>
<h2>පලතුරු ලැයිස්තුව</h2>
<ul>
<% 
    String[] fruits = {"ඇපල්", "කෙසෙල්", "අඹ", "මිදි"};
    for (String fruit : fruits) {
        out.println("<li>" + fruit + "</li>");
    }
%>
</ul>

මෙතනදි out.println() වලින් තමයි HTML output එකට යවන්නේ. ඒක Servlet එකේ response object එකට සමානයි.

2. Expressions (<%= ... %>)

දෙවෙනියට තියෙන්නේ Expressions. මේක නම් ගොඩක් ලේසියි. මොකද මේකෙන් කරන්නේ Java Variable එකක Value එකක් නැත්නම් Method එකකින් return වෙන value එකක් කෙලින්ම HTML output එකට දාන එක. මේක out.println() කියන එක ලියන්නේ නැතුව කෙලින්ම value එක print කරන කෙටි ක්‍රමයක් (shortcut). මතක තියාගන්න, Expression එකක් ඇතුලේ semicolon (;) එකක් දාන්නේ නෑ.

උදාහරණ:

<h2>Expression Example</h2>

<%-- Displaying current date and time --%>
<p>වර්තමාන වේලාව: <%= new java.util.Date() %></p>

<%-- Displaying a variable's value --%>
<% 
    String websiteName = "SC Developers";
    int year = 2024;
%>
<p>අපේ Website එක: <%= websiteName %> (වසර <%= year %>)</p>

<%-- Performing a simple calculation --%>
<p>5 + 3 = <%= 5 + 3 %></p>

දැන් තේරෙනවනේ, මේකෙන් out.println() නැතුව කෙලින්ම value එක print කරන්න පුලුවන්. මෙය scriptlets වලට වඩා පිරිසිදු සහ කෙටි ක්‍රමයක්.

3. Declarations (<%! ... %>)

අන්තිමට තියෙන්නේ Declarations. මේක ටිකක් විශේෂයි. මොකද මේකෙන් කරන්නේ Class Level එකේ Variables නැත්නම් Methods declare කරන එක. ඒ කියන්නේ මේවා JSP File එක Servlet එකක් බවට convert උනාම, ඒ Servlet Class එක ඇතුලෙම තමයි declare වෙන්නේ. සාමාන්‍ය Scriptlets වගේ _jspService() method එක ඇතුලේ නෙවෙයි.

මේ නිසා, මේවා JSP Page එකේ ඕනෑම තැනක පාවිච්චි කරන්න පුලුවන් වගේම, Server එක ආරම්භයේදී Servlet එක Load වෙනකොටම initialize වෙනවා. ඒ කියන්නේ මේ Declarations Page එකේ request ගානට create වෙන්නේ නැතුව, Servlet Instance එකක් පුරාම share වෙනවා. ඒ නිසා Instance variables (ඒ කියන්නේ counter වගේ variable එකක්) Declaration එකක් විදියට පාවිච්චි කරනකොට Thread Safety ගැන හොඳටම අවධානයෙන් ඉන්න ඕනේ. එක user කෙනෙක්ගේ data අනෙක් user කෙනාට පේන්න පුළුවන් (Data Corruption) නිසා මේක ඉතා වැදගත්.

උදාහරණ:

<h2>Declaration Example</h2>

<%!-- Declaration: Class-level variable (BE CAREFUL WITH STATE HERE!) --%>
<%! 
    private int pageVisitCount = 0; // This variable is shared across all users!
    
    // Declaration: Class-level method
    public String getFormattedDate(java.util.Date date) {
        java.text.SimpleDateFormat sdf = new java.text.SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        return sdf.format(date);
    }
%>

<% 
    // Scriptlet: Increment the declared variable (affects all users)
    pageVisitCount++;
%>

<p>මෙම පිටුවට මුළු පිවිසුම් ගණන (Server ආරම්භයේ සිට): <%= pageVisitCount %></p>
<p>අද දින: <%= getFormattedDate(new java.util.Date()) %></p>

<% 
    // Another declaration for demonstration
    public String welcomeMessage(String name) {
        return "ගොඩක් ආදරෙන් පිළිගන්නවා, " + name + " මහත්මයාණෙනි!";
    }
%>

<p><%= welcomeMessage("සුනිල්") %></p>

මේවා `request` එකක් ආවම Servlet Class එක Load වෙනකොටම initialize වෙනවා. ඒ නිසා pageVisitCount වගේ variable එකක් මේ විදියට පාවිච්චි කරනකොට Thread Safety ගැන අවධානයෙන් ඉන්න ඕනේ කියන එක ආයෙත් මතක් කරනවා. සාමාන්‍යයෙන් instance variables Declarations විදියට පාවිච්චි කරනවාට වඩා Methods declare කරන්න තමයි මේක ගොඩක් වෙලාවට පාවිච්චි කරන්නේ.

එකට එකතු කරලා බලමු! (Putting it all together!)

හරි, දැන් අපි මේ තුන්කට්ටුවම එකට දාලා පොඩි උදාහරණයක් බලමු. මේකෙන් මේවා එකට වැඩ කරන හැටි පැහැදිලි වෙයි. මේ example එකේදී අපි user ගේ නම request parameter එකකින් අරගෙන, ඒක display කරනවා, වගේම Page එකට ආපු මුළු පිවිසුම් ගණනකුත් (server එක ආරම්භයේ සිට) පෙන්නනවා.

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html lang="si">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>JSP Scripting Elements Demo</title>
    <style>
        body { font-family: Arial, sans-serif; margin: 20px; background-color: #f4f4f4; }
        .container { background-color: #fff; padding: 25px; border-radius: 8px; box-shadow: 0 0 10px rgba(0,0,0,0.1); }
        h1, h2 { color: #333; }
        p { line-height: 1.6; color: #555; }
        code { background-color: #e9e9e9; padding: 2px 4px; border-radius: 3px; }
        form { margin-top: 20px; }
        input[type="text"], input[type="submit"] { padding: 8px; margin-right: 5px; border: 1px solid #ddd; border-radius: 4px; }
        input[type="submit"] { background-color: #007bff; color: white; cursor: pointer; }
        input[type="submit"]:hover { background-color: #0056b3; }
    </style>
</head>
<body>
    <div class="container">
        <h1>අපේ JSP Scripting Elements Demo Page එක!</h1>

        <%!
            // Declaration: Class-level method for a standard greeting
            public String getStandardGreeting(String username) {
                return "ආයුබෝවන්, " + username + "!";
            }

            // Declaration: Class-level variable to count total server-wide visits
            // WARNING: This is shared across ALL user sessions! Not suitable for per-user count.
            private int totalServerVisits = 0;

            // Declaration: Another utility method
            public String getCurrentTimeFormatted() {
                java.text.SimpleDateFormat sdf = new java.text.SimpleDateFormat("HH:mm:ss");
                return sdf.format(new java.util.Date());
            }
        %>

        <% 
            // Scriptlet: Process request parameters
            String userProvidedName = request.getParameter("name");
            if (userProvidedName == null || userProvidedName.trim().isEmpty()) {
                userProvidedName = "අමුත්තා"; // Default name if not provided
            }
            
            // Scriptlet: Increment the declared server-wide visit counter
            totalServerVisits++; 
        %>

        <h2>පිළිගැනීමේ පණිවිඩය</h2>
        <p>
            <!-- Expression: Display greeting using the declared method -->
            <%= getStandardGreeting(userProvidedName) %>
        </p>

        <p>
            <!-- Expression: Display current time using a declared utility method -->
            දැන් වෙලාව: <%= getCurrentTimeFormatted() %>
        </p>

        <p>
            <!-- Expression: Display the server-wide visit count -->
            මෙම වෙබ් අඩවියට මුළු පිවිසුම් ගණන (Server ආරම්භයේ සිට): <%= totalServerVisits %>
            <small style="color: red;">(සටහන: මෙය Server එක පුරාම Share වන නිසා පරිශීලක සැසි ගණන නියෝජනය නොකරයි. Multi-user environment එකකදී භාවිතයට සුදුසු නැත.)</small>
        </p>

        <% 
            // Scriptlet: Conditional message based on visit count
            if (totalServerVisits > 5) {
                out.println("<p>අපේ වෙබ් අඩවියට නැවත නැවතත් පැමිණීම ගැන ස්තූතියි!</p>");
            }
        %>

        <h2>ඔබේ නම ඇතුලත් කර බලන්න</h2>
        <form action="index.jsp" method="get">
            <label for="nameInput">නම:</label>
            <input type="text" id="nameInput" name="name" placeholder="ඔබේ නම මෙතන දාන්න">
            <input type="submit" value="යවන්න">
        </form>

        <p><em>(මෙම පිටුව සාම්පලයක් පමණි. Real-world applications වලදී මේවා තවත් හොඳට manage කරන්න ඕනේ.)</em></p>
    </div>
</body>
</html>

මේ example එකේ totalServerVisits එක class level එකේ තියෙන නිසා හැම user කෙනෙක්ටම share වෙනවා. ඒක නිසා මේ වගේ variable එකක් request scope (request.setAttribute()) හෝ session scope (session.setAttribute()) එකේ තියෙන එක නැත්නම් Database එකකින් manage කරන එක වඩාත් සුදුසුයි. මේකෙදි මම ඒක පෙන්නුවේ <%! එකේ ක්‍රියාකාරීත්වය සහ එහි තිබෙන Thread Safety ගැටලුව පැහැදිලි කරන්න.

පොඩි Tips ටිකකුයි Best Practices ටිකකුයි! (Tips & Best Practices)

JSP Scripting Elements පාවිච්චි කරනකොට මතක තියාගන්න ඕන වැදගත් කරුණු ටිකක් තියෙනවා.

• Scriptlets වැඩිපුර පාවිච්චි කරන්න එපා (Minimize Scriptlets): JSP කියන්නේ Presentation Layer එක විතරයි. ඒ කියන්නේ User Interface එක හදන්න. Business Logic (database operations, complex calculations) වගේ දේවල් Java Servlets වල නැත්නම් වෙනම Java classes වල තියෙන එක තමයි හොඳම පුරුද්ද. මේකට Model-View-Controller (MVC) Architecture Pattern එක ගොඩක් උදව් වෙනවා. එතකොට code එක maintain කරන්න, test කරන්න, scalability වැඩි කරන්න ලේසියි. JSP file එකේ code වැඩි වෙන තරමට, ඒක කියවන්න, තේරුම් ගන්න අමාරු වෙනවා.
• JSP Cleanව තියාගන්න (Keep JSP Clean): JSP Page එක HTML වගේ පේන්න තියෙන තරමට හොඳයි. මේ Scripting elements වලින් වෙන්න ඕනේ HTML output එක generate කරන එක විතරයි. Complex Java logic JSP Page එක ඇතුලේ දාන එකෙන් code එක අවුල් වෙනවා. ඒ නිසා Presentation logic වලට විතරක් මේවා පාවිච්චි කරන්න.
• JSTL (JSP Standard Tag Library) සහ EL (Expression Language) පාවිච්චි කරන්න: ගොඩක් complex logic දේවල් වලට <% %> Scriptlets පාවිච්චි කරනවට වඩා JSTL (JSP Standard Tag Library) සහ EL (Expression Language) පාවිච්චි කරන එක ගොඩක් හොඳයි. JSTL Tag Libraries වලින් loops, conditionals, formatting වගේ දේවල් කරන්න පුළුවන්. ඒ වගේම EL වලින් Java Bean properties වලට access කරන්න පුළුවන්. මොකද ඒවා code එක කියවන්න ලේසි කරනවා වගේම error වෙන ප්‍රමාණයත් අඩු කරනවා. ඒ ගැන අපි වෙනම Post එකකින් කතා කරමු.
• Error Handling: JSP Page එකක් ඇතුලේ Errors manage කරන්න <%@ page errorPage="error.jsp" %> වගේ directives පාවිච්චි කරන්න පුළුවන්. ඒ වගේම Scriptlets ඇතුලේ Java try-catch blocks පාවිච්චි කරලා Exceptions handle කරන්න.

නිවුම (Conclusion)

ඉතින් යාලුවනේ, අද අපි කතා කලේ JSP වල තියෙන ප්‍රධානම Scripting Elements තුන ගැන - ඒ කියන්නේ Scriptlets (<% %>), Expressions (<%= %>), සහ Declarations (<%! %>) ගැන. මේවා හරියට තේරුම් ගත්තොත් Dynamic Web Pages හදන එක ඔයාලට ලේසි වෙයි. හැමදාම වගේ කියන්නේ, මේවා කියවනවට වඩා ඔයාලම code කරලා බලන එක තමයි හොඳම විදිය. පොඩි Project එකක් කරලා මේවා Implement කරලා බලන්න. මොකද Practice එක තමයි මේ හැම දේටම යතුර!

මේ Post එක ගැන ඔයාලට තියෙන අදහස්, ප්‍රශ්න පහලින් Comment section එකේ දාන්න. අපි ඒ ගැන කතා කරමු. ඔයාලගේ අදහස් අපිට ගොඩක් වටිනවා! තවත් අලුත් Technical Article එකකින් ඉක්මනින්ම හමුවෙමු! Java Development වලට කැමති යාළුවන්ටත් මේක share කරන්න අමතක කරන්න එපා. ජයවේවා!