JSTL: JSP පහසුවෙන් හදමු! - JavaServer Pages Standard Tag Library SC Guide

ආයුබෝවන් යාලුවනේ! කොහොමද ඉතින්? අද අපි කතා කරන්න යන්නේ Java Web Development ලෝකයේ, විශේෂයෙන්ම JSP (JavaServer Pages) වලදී ඔයාලගේ වැඩ ගොඩක් ලේසි කරගන්න පුළුවන් පට්ට ටූල් එකක් ගැන – ඒ තමයි JSTL, නැත්නම් JavaServer Pages Standard Tag Library එක. සාමාන්‍යයෙන්, JSP වලදී HTML එක්ක Java code mix කරලා ලියන්න ගියාම වැඩේ අවුල් වෙන්න, අවුල් වෙලා පැටලෙන්න තියෙන ඉඩ වැඩියි. හැබැයි JSTL පාවිච්චි කරොත් මේක මාර විදියට සිම්පල් කරගන්න පුළුවන්.

මතකද ඉස්සර අපි JSP වලදී scriptlets (ඒ කියන්නේ <% %> ටැග් ඇතුළේ Java code ලියන එක) පාවිච්චි කරලා ලූප, කන්ඩිෂන් චෙක් වගේ දේවල් කරපු හැටි? ඒක සමහර වෙලාවට ලොකු රිස්ක් එකක්. Code එක HTML එක්ක පැටලිලා, කියවන්න අමාරු වෙලා, පස්සේ ඒක maintain කරන්නත් ලොකු අමාරුවක්. අන්න ඒ වගේ අවුල් ටිකක් නැති කරගන්න තමයි JSTL අපිට උදව් කරන්නේ. ඉතින් අපි බලමු මේ JSTL කියන්නේ මොකක්ද, කොහොමද මේක පාවිච්චි කරන්නේ කියලා. අපි ලේසිම විදියට, Practical උදාහරණ එක්ක මේක ඉගෙන ගමු. Ready ද? එහෙනම් පටන් ගමු!

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

JSTL කියන්නේ JavaServer Pages Standard Tag Library එක. නමින්ම තේරෙනවා නේ, මේක Tag Library එකක්. JSP කියන්නේ HTML වගේ markup language එකක් ඇතුළේ Java code ලියන්න පුළුවන් ටෙක්නොලොජි එකක්. ඉස්සර අපි මේකට scriptlets (<% %>) පාවිච්චි කළා. හැබැයි මේ scriptlets වලින් ලොකු ගැටලු ගණනාවක් ආවා.

Scriptlets වල අවුල

හිතන්න ඔයාලට JSP Page එකක HTML table එකක් ඇතුළට Database එකකින් ගත්ත data ටිකක් පෙන්නන්න ඕනේ කියලා. සාමාන්‍යයෙන් අපි ඒකට මෙහෙම scriptlets පාවිච්චි කළා:

<%-- Example using scriptlets --%>
<% 
    List<String> items = (List<String>) request.getAttribute("items");
    if (items != null) {
        for (String item : items) {
%>
        <p><%= item %></p>
<% 
        }
    }
%>

මේක බලන්න, Java code එක HTML ටැග්ස් එක්ක පැටලිලා. මේක පොඩි program එකකට අවුලක් නැති උනාට, ලොකු program එකකදි මේ code එක maintain කරන එක මාරම අමාරු වැඩක්. Front-end එක හදන කෙනෙකුට මේ Java code තේරුම් ගන්නත් ඕනේ, Back-end එක හදන කෙනෙකුට HTML Structure එක තේරුම් ගන්නත් ඕනේ. ඔය වගේ වෙලාවට Code එක කියවන්න, තේරුම් ගන්න, වෙනස් කරන්න අමාරු වෙනවා. ඒ වගේම, Code readability, reusability වගේ දේවලුත් ගොඩක් අඩු වෙනවා.

JSTL වලින් ලැබෙන විසඳුම

JSTL කරන්නේ මේ scriptlets වෙනුවට ready-made custom tags ටිකක් අපිට දෙන එක. මේ Tags වලින් පුළුවන් Common tasks (data looping, conditional logic, data formatting, XML manipulation, database access) වගේ දේවල් කරන්න. ඒ කියන්නේ, උඩ තිබ්බ Java code එක HTML වගේම පේන Tags වලට convert කරනවා. ඒක හරිම elegant Solution එකක්. මේ Tags Standardize කරලා තියෙන නිසා, හැමෝටම තේරුම් ගන්න ලේසියි. Code එක clean වෙනවා, Maintainability වැඩි වෙනවා, Developersලාට වැඩේ ගොඩක් ලේසි වෙනවා.

JSTL Tag Libraries ප්‍රධාන වශයෙන් පහකට බෙදෙනවා:

• Core Tags: (Prefix c) - Variables define කරන එක, iteration (loop), conditional logic (if-else) වගේ දේවල් වලට.
• Formatting Tags: (Prefix fmt) - Numbers, dates, times, currency වගේ දේවල් Format කරන්න.
• SQL Tags: (Prefix sql) - Direct Database access කරන්න (ඒත් මේක Production වලට recommend කරන්නේ නැහැ, MVC architecture එක පාවිච්චි කරන එක තමයි හොඳ).
• XML Tags: (Prefix x) - XML data process කරන්න.
• Functions Tags: (Prefix fn) - Common String manipulation, collection operations වගේ දේවල් වලට.

අපි මේ ලිපියේදී Core Tags වලට වැඩි අවධානයක් දෙමු, මොකද ඒවා තමයි වැඩිපුරම භාවිත වෙන්නේ.

JSTL Setup කරමු

JSTL පාවිච්චි කරන්න නම් අපේ project එකට JSTL library එක එකතු කරගන්න ඕනේ. ඔයාලා Maven හෝ Gradle පාවිච්චි කරනවා නම් වැඩේ ගොඩක් ලේසියි.

Maven/Gradle Dependency

ඔයාලගේ pom.xml (Maven) හෝ build.gradle (Gradle) ෆයිල් එකට පහත dependency එක එකතු කරන්න:

Maven:

<dependencies>
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>jstl</artifactId>
        <version>1.2</version>
    </dependency>
</dependencies>

Gradle:

dependencies {
    implementation 'javax.servlet:jstl:1.2'
}

මේ dependency එක add කරාට පස්සේ, ඔයාලගේ project එක build කරන්න. එතකොට JSTL JAR file එක project එකට add වෙනවා. ඊට පස්සේ ඔයාලගේ JSP pages වලදී JSTL tags පාවිච්චි කරන්න පුළුවන්.

JSP page එකක JSTL tags පාවිච්චි කරන්න කලින්, page එකේ උඩම line එකේ Tag Library Descriptor (TLD) එක define කරන්න ඕනේ. මේකෙන් වෙන්නේ අපි පාවිච්චි කරන JSTL tags මොන prefix එකකින්ද හඳුන්වන්නේ කියලා specify කරන එකයි. Core tags වලට සාමාන්‍යයෙන් c කියන prefix එක පාවිච්චි කරනවා.

<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>

මේ line එක ඔයාලගේ හැම JSP page එකකම, JSTL Core tags පාවිච්චි කරනවා නම්, අනිවාර්යයෙන්ම add කරන්න ඕනේ. ඒ වගේම c වෙනුවට ඕනෑම අකුරක් prefix එක විදියට දෙන්න පුළුවන්. හැබැයි c කියන එක Standard convention එකක්.

JSTL Tags ගැන බලමු - c:forEach

JSTL වල තියෙන පට්ටම Tag එකක් තමයි <c:forEach> Tag එක. මේක සාමාන්‍යයෙන් Java වල තියෙන for loop, for-each loop එක වගේම තමයි වැඩ කරන්නේ. Collections (List, Set), Arrays වගේ දේවල් iterate කරන්න (ඒ කියන්නේ එකින් එකට access කරන්න) මේක පාවිච්චි කරනවා.

c:forEach - ලූපයක් වගේ වැඩ කරන හැටි

හිතන්න, ඔයාලගේ Servlet එකකින් JSP page එකට studentsලාගේ names ටිකක් List එකක් විදියට එවනවා කියලා. ඒ List එකේ තියෙන හැම student කෙනෙක්ගෙම නම වෙන වෙනම පෙන්නන්න ඕනේ නම්, <c:forEach> පාවිච්චි කරන්න පුළුවන්. Servlet එකෙන් අපි List එක request attribute එකක් විදියට set කරලා යවමු:

// In your Servlet
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@WebServlet("/students")
public class StudentServlet extends HttpServlet {
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        List<String> studentNames = new ArrayList<>();
        studentNames.add("Kasun");
        studentNames.add("Nimali");
        studentNames.add("Sarath");
        studentNames.add("Priya");
        request.setAttribute("students", studentNames);
        request.getRequestDispatcher("students.jsp").forward(request, response);
    }
}

දැන් students.jsp file එකේ මේ List එක iterate කරලා පෙන්නමු:

<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>Student List</title>
</head>
<body>
    <h1>අපේ Student ලා ටික</h1&n
    <ul>
        <c:forEach var="student" items="${students}">
            <li>${student}</li>
        </c:forEach>
    </ul>

    <h2>අපේ Student ලා ටික (index එකත් එක්ක)</h2>
    <table border="1">
        <tr>
            <th>Index</th>
            <th>Student Name</th>
        </tr>
        <c:forEach var="student" items="${students}" varStatus="loop">
            <tr>
                <td>${loop.index + 1}</td> <!-- loop.index starts from 0 -->
                <td>${student}</td>
            </tr>
        </c:forEach>
    </table>
</body>
</html>

මෙහිදී,

• var="student": මේකෙන් කියන්නේ List එකේ හැම item එකකටම student කියන නම තාවකාලිකව පාවිච්චි කරන්න පුළුවන් කියලා.
• items="${students}": මේකෙන් කියන්නේ අපි iterate කරන්න යන Collection එකේ නම. මෙතන ${students} කියන්නේ Expression Language (EL) එක. EL එකෙන් පුළුවන් Scope variables (request, session, application), JavaBeans properties වගේ දේවල් access කරන්න.
• varStatus="loop": මේක optional attribute එකක්. මේක පාවිච්චි කරොත් loop එකේ status එක (current index, count, first, last, even, odd වගේ) දැනගන්න පුළුවන්. උදාහරණයෙන් පේනවා නේ loop.index වලින් current index එක ගන්න පුළුවන්.

දැන් බලන්න, කලින් තිබ්බ scriptlets වලට වඩා මේ JSTL code එක කොච්චර කියවන්න ලේසිද කියලා. HTML වගේම පේනවා නේ? වැඩේ පට්ට නේද?

JSTL Tags ගැන බලමු - c:if

ඊළඟට අපි බලමු <c:if> Tag එක. මේක Java වල if statement එක වගේම තමයි වැඩ කරන්නේ. යම්කිසි condition එකක් true නම්, ඒ Tag එක ඇතුළේ තියෙන content එක display කරනවා, නැත්නම් skip කරනවා.

c:if - කන්ඩිෂන් චෙක් කරන හැටි

හිතන්න, ඔයාලට JSP Page එකක user කෙනෙක් Administrator කෙනෙක්ද කියලා check කරලා, එයාට විතරක් විශේෂ button එකක් පෙන්නන්න ඕනේ කියලා. Servlet එකෙන් userRole එක request attribute එකක් විදියට set කරලා යවමු:

// In your Servlet
import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@WebServlet("/dashboard")
public class DashboardServlet extends HttpServlet {
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        String userRole = "Admin"; // Or "User" or any other role
        request.setAttribute("role", userRole);
        request.getRequestDispatcher("dashboard.jsp").forward(request, response);
    }
}

දැන් dashboard.jsp file එකේ මේ condition එක check කරලා button එක පෙන්නමු:

<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>Dashboard</title>
</head>
<body>
    <h1>Dashboard එකට සාදරයෙන් පිලිගනිමු!</h1>

    <p>ඔබේ Role එක: <b>${role}</b></p>

    <c:if test="${role == 'Admin'}">
        <button>Admin Panel එකට යන්න</button>
    </c:if>

    <c:if test="${role != 'Admin'}">
        <p>ඔබට Admin Panel එකට යාමට අවසර නැත.</p>
    </c:if>

    <!-- else if වගේ functionality එකට c:choose, c:when, c:otherwise පාවිච්චි කරන්න පුළුවන්. -->
    <h2>Role එක අනුව වෙනස් දේවල් පෙන්නන හැටි</h2>
    <c:choose>
        <c:when test="${role == 'Admin'}">
            <p>ඔබ පරිපාලකවරයෙක් වන බැවින් සියලුම අංග වෙත ප්‍රවේශ විය හැක.</p>
        </c:when>
        <c:when test="${role == 'User'}">
            <p>ඔබ සාමාන්‍ය පරිශීලකයෙක් වන බැවින් සීමිත අංග වෙත ප්‍රවේශ විය හැක.</p>
        </c:when>
        <c:otherwise>
            <p>ඔබේ Role එක හඳුනාගත නොහැක.</p>
        </c:otherwise>
    </c:choose>

</body>
</html>

මෙහිදී,

• test="${role == 'Admin'}": මේක තමයි condition එක. ${role} කියන්නේ EL එකෙන් request attribute එකෙන් ගත්ත role variable එක. මේක Admin කියන String එකට සමාන නම් condition එක true වෙනවා.

Java වල if-else if-else statement එක වගේ දෙයක් කරන්න JSTL වල <c:choose>, <c:when>, <c:otherwise> Tags ටික පාවිච්චි කරන්න පුළුවන්. උඩ උදාහරණයේම ඒකත් තියෙනවා.

තව JSTL Tags ටිකක්

Core Tags වල <c:forEach>, <c:if> වලට අමතරව තව ගොඩක් ප්‍රයෝජනවත් Tags තියෙනවා:

<c:url>: URL එකක් encode කරන්න සහ parameter එකතු කරන්න පාවිච්චි කරනවා.

<a href="<c:url value='/product' ><c:param name='id' value='123'/></c:url>">Product Details</a>
        

<c:redirect>: Request එකක් වෙන URL එකකට redirect කරන්න පාවිච්චි කරනවා.

<c:redirect url="welcome.jsp"/>
        

<c:out>: Variable එකක value එක print කරන්න පාවිච්චි කරනවා. මේක XSS (Cross-Site Scripting) attacks වලින් ආරක්ෂා වෙන්න Escaping automatically කරනවා.

<c:out value="${userComment}" default="No comment provided"/>
        

<c:set>: Scope එකක් ඇතුළේ variable එකක් define කරන්න හෝ value එකක් set කරන්න පාවිච්චි කරනවා.

<c:set var="userName" value="Kamal Perera" scope="session"/>
<p>User Name: ${userName}</p>
        

මේ Tags ටික පාවිච්චි කරලා ඔයාලට පුළුවන් ඔයාලගේ JSP Pages Clean කරගන්න. Java Code එක HTML වලින් වෙන් කරලා, වඩා හොඳ Structure එකකට එන්න JSTL ගොඩක් උදව් වෙනවා.

නිගමනය (Conclusion)

ඉතින් යාලුවනේ, අද අපි කතා කළේ Java Web Development වල JSP හදනකොට අපිට ගොඩක් වටින JSTL, නැත්නම් JavaServer Pages Standard Tag Library එක ගැන. කලින් තිබ්බ scriptlets වලින් ඇතිවෙන අවුල් ටික අඩු කරලා, වඩා Clean, Maintainable, readable code එකක් ලියන්න JSTL අපිට උදව් වෙනවා.

අපි <c:forEach> පාවිච්චි කරලා Data Collections iterate කරන හැටිත්, <c:if> සහ <c:choose> පාවිච්චි කරලා conditional logic එකතු කරන හැටිත් බැලුවා. මේවාට අමතරව තව ගොඩක් Tags JSTL එකේ තියෙනවා, ඒ හැම එකක්ම ඔයාලගේ Web Development journey එක පහසු කරනවා නිසැකයි.

දැන් ඔයාලට පුළුවන් මේ concepts පාවිච්චි කරලා ඔයාලගේම JSP Project එකක් පටන් ගන්න. Try කරලා බලන්න, අතින්ම කරනකොට තමයි ගොඩක් දේවල් පැහැදිලි වෙන්නේ. මේ ගැන ඔයාලගේ අදහස්, ප්‍රශ්න තියෙනවා නම් පහලින් comment කරන්න. අපි සේරම එකතුවෙලා දැනුම බෙදා ගමු. එහෙනම් තවත් අලුත් ලිපියකින් හමුවෙමු! Good Luck!