JSP: Web Applications වලට පණ දෙන හැටි SC Guide

කොහොමද යාලුවනේ! අද අපි කතා කරන්න යන්නේ Web Applications හදන ඔයාලට පට්ටම වැදගත් වෙන, Java world එකේ dynamic web content හදන්න පාවිච්චි කරන ටෙක්නොලොජි එකක් ගැන – ඒ තමයි JSP (JavaServer Pages).

අපි හිතමු ඔයාට Facebook වගේ වෙබ් අඩවියක් හදන්න ඕන කියලා. ඒකෙ හැම user කෙනාටම එකම content එකක් නෙවෙයි පෙන්වන්නේ නේද? කෙනෙක් login වුනාම එයාගේ profile එක, එයාගේ friends ලගේ posts වගේ දේවල් තමයි පෙන්වන්නේ. මේ වගේ දේවල් කරන්න අපිට නිකන්ම HTML වලින් බැහැ. මොකද HTML කියන්නේ static content පෙන්නන්න විතරයිනේ පාවිච්චි කරන්නේ. එතකොට මෙහෙම dynamic විදියට data පෙන්නන්න අපි මොකද කරන්නේ?

අන්න එතනට තමයි JSP වගේ technologies එන්නේ. JSP කියන්නේ Java programming language එකයි, HTML, XML වගේ markup languages යොදාගෙන web pages හදන්න පුළුවන් server-side technology එකක්. මේකෙන් පුළුවන් client ගේ request එකට අනුව dynamically web pages generate කරන්න.

ඉතින් අපි බලමු JSP කියන්නේ මොකක්ද? ඒකෙන් මොනවද කරන්න පුළුවන්? කොහොමද ඒක වැඩ කරන්නේ කියලා පියවරෙන් පියවර.

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

සරලවම කිව්වොත්, JSP කියන්නේ Java based web technology එකක්. මේක Oracle සමාගමෙන් හඳුන්වා දීලා තියෙන්නේ web application development වලට. මේක Java Servlet technology එකේම extension එකක් විදියටත් හඳුන්වන්න පුළුවන්. JSP pages වලින් පුළුවන් HTML pages ඇතුලට Java code embed කරලා dynamic web content generate කරන්න. ඒ කියන්නේ ඔයාට පුළුවන් HTML tags එක්කම Java code එකත් එකම page එකක ලියන්න.

JSP වල ප්‍රධානම අරමුණ තමයි presentation layer එක (user ට පේන කොටස) business logic එකෙන් වෙන් කරලා තියන්න පුළුවන් විදියට framework එකක් සපයන එක. ඒ කියන්නේ designer කෙනෙක්ට HTML part එක කරන්න පුළුවන්, programmer කෙනෙක්ට Java logic එක ලියන්න පුළුවන්. මේකෙන් project එකක වැඩ බෙදාගන්න එක ලේසි වෙනවා.

JSP කොහොමද වැඩ කරන්නේ? (How JSP Works?)

මෙන්න මේක ගොඩක් අය confuse වෙන තැනක්. JSP page එකක් server එකට request එකක් ආවම ඒක කෙලින්ම run වෙන්නේ නැහැ. වෙන්නේ මෙහෙම දෙයක්:

1. මුලින්ම, JSP page එක Servlet එකක් බවට compile වෙනවා. (අපිට පේන්නේ නැති backend process එකක්).
2. ඊට පස්සේ, ඒ compile වුණු Servlet එක සාමාන්‍ය Servlet එකක් වගේම server එකේ execute වෙනවා.
3. ඒ execute වීමේ ප්‍රතිඵලයක් විදියට generate වෙන HTML code එක client (browser) එකට send කරනවා.

මේ process එක ඔක්කොම සිද්ද වෙන්නේ server-side එකේ. ඒ නිසා client ට පේන්නේ final HTML page එක විතරයි. JSP code එක පේන්නේ නැහැ. මේක තමයි server-side scripting වල ලොකුම වාසියක්.

JSP වල මූලික Elements (Basic JSP Elements)

JSP pages හදද්දී අපි පාවිච්චි කරන ප්‍රධාන කොටස් කීපයක් තියෙනවා. මේවා නැතුව JSP කරන්න බැහැ. අපි එකින් එක බලමු.

1. Directives (උපදෙස්)

මේවා JSP container එකට (Tomcat වගේ) කියනවා JSP page එක compile කරද්දී කොහොමද හැසිරෙන්න ඕන කියලා. මේවා පටන් ගන්නේ <%@ වලින්.

<%@ taglib ... %>: මේකෙන් custom tag libraries (JSTL වගේ) JSP page එකට import කරන්න පුළුවන්.

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

<%@ include ... %>: මේකෙන් වෙනත් JSP page එකක හෝ HTML file එකක content එක දැනට තියෙන page එකට include කරන්න පුළුවන්. මේක compile කාලයේදී සිදුවෙනවා. (Static include).

<%@ include file="header.jsp" %>

<%@ page ... %>: මේකෙන් page එකේ properties define කරනවා. උදාහරණයක් විදියට, Java classes import කරන්න, error page එකක් specify කරන්න වගේ දේවල් මේකෙන් කරන්න පුළුවන්.

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>

2. Scriptlets (ස්ක්‍රිප්ට්ලට්)

මේවා තමයි JSP page එක ඇතුලේ Java code ලියන්න පාවිච්චි කරන්නේ. මේවා <% සහ %> ඇතුලේ ලියනවා. මේ code එක Servlet එකේ _jspService() method එක ඇතුලේ run වෙනවා.

<% 
    String name = "ලංකාවේ programmers";
    out.println("ආයුබෝවන්, " + name + "!");
%>

3. Expressions (ප්‍රකාශන)

මේවා <%= සහ %> ඇතුලේ ලියනවා. මේවා පාවිච්චි කරන්නේ Java variable එකක හෝ expression එකක value එක කෙලින්ම HTML output එකට print කරන්න. out.println() කියල දාන්න ඕන නැහැ.

<% 
    java.util.Date date = new java.util.Date();
%>

අද දින වේලාව: <%= date %>

4. Declarations (ප්‍රකාශන)

මේවා <%! සහ %> ඇතුලේ ලියනවා. මේවා පාවිච්චි කරන්නේ JSP page එකේ method හෝ variable define කරන්න. මේවා define වෙන්නේ Servlet class එක ඇතුලේ, _jspService() method එකෙන් පිට. ඒ නිසා මේවා JSP page එකේ හැම request එකකටම පොදුයි.

<%! 
    int counter = 0;
    public String getMessage() {
        return "Welcome to JSP!";
    }
%>

<h3><%= getMessage() %></h3>
<p>Page views: <%= ++counter %></p>

5. Comments (අදහස්)

මේවා <%-- සහ --%> ඇතුලේ ලියනවා. මේවා compile වෙද්දී remove වෙනවා. ඒ නිසා client ට පේන්නේ නැහැ, source code එකේවත් නැහැ. HTML comments (<!-- ... -->) server එකෙන් client ට send කරනවා.

<%-- This is a JSP comment --%>
<!-- This is an HTML comment -->

JSP Lifecycle එක සහ Implicit Objects (JSP Lifecycle and Implicit Objects)

JSP page එකක් request එකක් ආවම කොහොමද වැඩ කරන්නේ කියලා තේරුම් ගන්න JSP Lifecycle එක දැනගෙන ඉන්න එක වැදගත්.

JSP Lifecycle එක

1. Translation Phase: JSP page එක Java Servlet source code එකකට convert කරනවා.
2. Compilation Phase: Java Servlet source code එක compile කරලා Java Servlet class file එකක් (.class) හදනවා.
3. Loading Phase: Servlet class file එක JVM (Java Virtual Machine) එකට load කරනවා.
4. Instantiation Phase: Servlet class එකේ instance එකක් හදනවා.
5. Initialization Phase: jspInit() method එක execute කරනවා. මේක Servlet එක load වුනාට පස්සේ එක වරක් විතරයි call වෙන්නේ. Common resources load කරන්න මේක පාවිච්චි කරනවා.
6. Request Processing Phase: _jspService() method එක execute කරනවා. හැම client request එකකටම මේ method එක execute වෙනවා. අපේ JSP code එක run වෙන්නේ මේක ඇතුලේ.
7. Destroy Phase: Servlet instance එක destroy වෙන්න කලින් jspDestroy() method එක execute කරනවා. Resources release කරන්න මේක පාවිච්චි කරනවා.

Implicit Objects (නැත්නම් Built-in Objects)

JSP වල අපිට කලින්ම define කරලා දීලා තියෙන objects 9ක් තියෙනවා. මේවා අපිට scriptlets සහ expressions ඇතුලේ කෙලින්ම පාවිච්චි කරන්න පුළුවන්. මේවා තමයි:

• request: Client ගේ request එකට අදාළ තොරතුරු (parameters, headers, cookies වගේ) අඩංගු වෙනවා.
• response: Server එකෙන් client ට යවන response එක control කරන්න පාවිච්චි කරනවා (redirect කරන්න, headers set කරන්න වගේ).
• session: User ගේ session එකට අදාළ තොරතුරු (user login තත්වය, cart එකේ තොරතුරු වගේ) store කරන්න පුළුවන්.
• application: Web application එකේ හැම user කෙනෙකුටම පොදු තොරතුරු store කරන්න පුළුවන්. (Server startup එකේ ඉඳන් shutdown වෙනකන් තියෙනවා).
• out: Response එකට content print කරන්න පාවිච්චි කරන JspWriter object එක.
• config: Servlet configuration information අඩංගු වෙනවා.
• pageContext: Page එකේ context information අඩංගු වෙනවා. (වෙනත් implicit objects වලට access කරන්න පුළුවන්).
• page: JSP page එකේම instance එක. (this reference එකට සමානයි).
• exception: Error page එකකදී exception object එකට access කරන්න පුළුවන්.

මේවා අතරින් request, response, session, application, out කියන ටික තමයි ගොඩක්ම පාවිච්චි වෙන්නේ.

උදාහරණයක් විදියට, URL එකේ parameter එකක් ගන්න හැටි බලමු:

<% 
    String userName = request.getParameter("name");
    if (userName != null && !userName.isEmpty()) {
        out.println("ආයුබෝවන්, " + userName + "!");
    } else {
        out.println("ඔබගේ නම ඇතුලත් කරන්න.");
    }
%>

මේක බලන්න පුළුවන් yourpage.jsp?name=Nimal වගේ URL එකකට ගිහින්.

Practical JSP Example: Simple User Greeting (සරල JSP උදාහරණයක්: පරිශීලකයෙකුට සුබ පතමු)

හරි, දැන් අපි පොඩි Practical Example එකක් කරලා බලමු. මේකෙන් අපි User කෙනෙක්ගෙන් නමක් අරගෙන, ඒ නම පෙන්වලා සුබ පතනවා.

පියවර 1: HTML Form එක (index.html)

මුලින්ම අපි user ගේ නම ගන්න form එකක් හදමු. මේක index.html කියලා save කරන්න.

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>නම ඇතුලත් කරන්න</title>
</head>
<body>
    <h1>ඔබගේ නම ඇතුලත් කරන්න</h1>
    <form action="greeting.jsp" method="GET">
        <label for="userName">ඔබේ නම:</label>
        <input type="text" id="userName" name="userName" required>
        <br><br>
        <button type="submit">Submit</button>
    </form>
</body>
</html>

මෙහිදී form එකේ action="greeting.jsp" කියලා දීලා තියෙන්නේ user submit කළාම greeting.jsp කියන page එකට යවන්න. method="GET" කියන්නේ data URL එක හරහා යවනවා කියන එක.

පියවර 2: JSP Greeting Page එක (greeting.jsp)

දැන් අපි greeting.jsp page එක හදමු. මේකෙන් index.html එකෙන් ආපු නම අරගෙන display කරනවා.

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>සුබ පැතුම්</title>
</head>
<body>
    <h1>ඔබට සුබ පැතුම්!</h1>
    <% 
        String userName = request.getParameter("userName");
        if (userName != null && !userName.trim().isEmpty()) {
    %>
            <p>ආයුබෝවන්, <strong><%= userName %></strong>! අපගේ වෙබ් අඩවියට සාදරයෙන් පිළිගනිමු.</p>
    <% } else { %>
            <p>ඔබ නමක් ඇතුලත් කළේ නැහැ. කරුණාකර නැවත උත්සාහ කරන්න.</p>
    <% } %>
    <br>
    <a href="index.html">නැවත යන්න</a>
</body>
</html>

මෙහිදී අපි request.getParameter("userName") පාවිච්චි කරලා index.html එකේ form එකෙන් ආපු userName කියන parameter එකේ value එක ගන්නවා. ඊට පස්සේ ඒක out.println() හෝ expression (<%= ... %>) පාවිච්චි කරලා display කරනවා.

මේක Run කරන්නේ කොහොමද?

මේ වගේ JSP application එකක් run කරන්න ඔයාට Servlet Container එකක් ඕන වෙනවා. Apache Tomcat, GlassFish, Jetty වගේ server එකක් පාවිච්චි කරන්න පුළුවන්. සාමාන්‍යයෙන් ඔයාට මේ files දෙක (index.html සහ greeting.jsp) web server එකේ webapps/YourAppName වගේ folder එකකට දාලා run කරන්න පුළුවන්. IDE එකක් (Eclipse, IntelliJ IDEA) පාවිච්චි කරනවා නම් ඒකෙන් direct deployment කරන්න පුළුවන්.

JSP භාවිතයේදී මතක තියාගන්න දේවල් සහ Best Practices (Things to Remember and Best Practices when using JSP)

JSP powerful වුණාට, ඒක හරියට පාවිච්චි නොකළොත් code එක අවුල් වෙන්න පුළුවන්.

• Scriptlets අඩුවෙන් පාවිච්චි කරන්න: JSP වල <% ... %> කියන scriptlets පාවිච්චි කරලා ඕනෑම Java code එකක් ලියන්න පුළුවන්. හැබැයි ඕනෑවට වඩා business logic JSP page එක ඇතුලට දැම්මොත් code එක කියවන්නත්, maintain කරන්නත් අමාරු වෙනවා. මේක Design Pattern වලට අනුව හොඳ දෙයක් නෙවෙයි.
• JSTL (JSP Standard Tag Library) සහ EL (Expression Language) පාවිච්චි කරන්න: JSTL කියන්නේ JSP වලටම හදපු tag library එකක්. මේකෙන් loops, conditionals, formatting වගේ දේවල් කරන්න පුළුවන්, scriptlets පාවිච්චි නොකර. EL කියන්නේ variables වල value print කරන්න තියෙන පහසු ක්‍රමයක්. මේ දෙකම පාවිච්චි කරන එක code එක clean කරගන්න ගොඩක් උදව් වෙනවා.
  උදාහරණයක්: <c:forEach>, <c:if> tags සහ ${param.userName} වගේ EL expressions.
• MVC (Model-View-Controller) Pattern එක යොදාගන්න: JSP වලදී presentation (View) එක Servlets (Controller) වලින් සහ JavaBeans (Model) වලින් වෙන් කරලා තියෙන එක හොඳම practice එකක්. මේකෙන් code එක organize කරගන්නත්, test කරන්නත් ලේසි වෙනවා.
• Input Validation: User ලගෙන් input ගන්න හැම වෙලාවකම server-side එකේ validation කරන්න. මේක security වලටත් අත්‍යවශ්‍යයි.
• Security Considerations: XSS (Cross-Site Scripting) වගේ attacks වලින් ආරක්ෂා වෙන්න output එක encode කරන්න. Sensitive data direct JSP එකේ print කරන එකෙන් වළකින්න.

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

JSP කියන්නේ dynamic web applications හදන්න තියෙන ඉතාම ප්‍රයෝජනවත් technology එකක්. මේකෙන් ඔයාලට HTML එක්ක Java code mix කරලා ලේසියෙන්ම user interactive web pages හදන්න පුළුවන්. අදටත් enterprise-level Java web applications ගොඩක් JSP පාවිච්චි කරනවා.

මේක තවත් deep වෙලා ඉගෙන ගන්න ගොඩක් දේවල් තියෙනවා. JavaBeans, JSTL, EL, Custom Tags වගේ දේවල් ගැනත් ඔයාලට ඉස්සරහට ඉගෙන ගන්න පුළුවන්.

ඉතින් මොකද හිතන්නේ? JSP ගැන ඔයාලගේ අදහස් පහලින් comment කරන්න. මේ blog post එක ගැන ඔයාලට තියෙන ප්‍රශ්න හෝ තව මොනවා හරි දැනගන්න ඕන නම් අහන්න. අපි ඊළඟ post එකෙන් හමුවෙමු! Happy Coding!