วันจันทร์ที่ 13 กันยายน พ.ศ. 2553

การใช้ session จดจำข้อมูล

เราสามารถใช้วัตถุแฝง session จดจำข้อมูลได้คล้ายกับคุ๊กกี้ แต่แทนที่จะซ่อนข้อมูลเก่าไว้
ในฮาร์ดดิสก์ของผู้เยี่ยมชมจะใช้การเก็บข้อมูลไว้บนฝั่งเวบเซิร์ฟเวอร์แทน ข้อดีของการทำ
แบบนี้ก็คือ ในบางครั้งผู้เยี่ยมชมที่เป็นห่วงเรื่องของความปลอดภัยและความเป็นส่วนตัวจึง
กำหนดให้เบราเซอร์บนเครื่องคอมพิวเตอร์ของตนไม่ให้รับคุ๊กกี้จากเวบไซต์ การใช้ session
ทำงานแทนคุ๊กกี้จะไม่มีปัญหาตรงจุดนี้เพราะไม่มีการหยอดคุ๊กกี้ลงบนเบราเซอร์ของผู้เยี่ยม
ชมแต่ประการใด
อย่างไรก็ดี วัตถุแฝง session มี scope เป็นแบบ session ดังนั้นจึงจดจำข้อมูลของผู้เยี่ยม
ชมได้เฉพาะชั่วขณะที่ผู้เยี่ยมชมยังติดต่อกับเวบไซต์อยู่หรือตราบเท่าที่ยังไม่ปิดเบราเซอร์
เมื่อผู้เยี่ยมชมปิดการทำงานของเบราเซอร์ข้อมูลเหล่านั้นก็จะหายไป ดังนั้นการใช้ session
เก็บข้อมูลอาจจะไม่เหมาะกับการจดจำชื่อสมาชิกและรหัสลับอย่างในกรณีของคุ๊กกี้ในตัว
อย่างที่ผ่านมา แต่จะเหมาะกับการใช้จดจำว่าผู้เยี่ยมชมรายใดได้ล็อกอินไปแล้วบ้าง ตราบ
เท่าที่ผู้เยี่ยมชมรายนั้นยังไม่ปิดเบราเซอร์ผู้เยี่ยมชมไม่ต้องล็อกอินอีก

เราจะลองใช้ session กับระบบสมาชิกที่เราได้สร้างไว้ก่อนหน้านี้ โดย session จะทำหน้าที่
จดจำเบราเซอร์ที่ล็อกอินแล้ว เมื่อเวลาที่ผู้เยื่ยมชมต้องการข้ามไปดูเวบหน้าอื่น เวบหน้า
นั้นๆ จะตรวจสอบว่าผู้เยี่ยมชมล็อกอินแล้วหรือยังด้วยการสืบค้นจาก session
วัตถุแฝง session มีแมธธอสชื่อ setAttribute() และ getAttribute() ซึ่งใช้บันทึกและเรียกดู
ข้อมูลอะไรก็ได้ ดูไปแล้วก็คล้ายกับคุ๊กกี้ ลองพิจารณาโปรแกรมที่ปรับปรุงใหม่ต่อไปนี้

<% String username = request.getParameter("username");
String password = request.getParameter("password");
%>
<html>
<title>Login</title>
<body>
<% if (username.equals("Songkarn")&&password.equals("12345")) {
session.setAttribute("isLoggedin","yes");
%>
Login successful.
<% } else { %>
Login failed.
<% } %>
</body>
</html>

โปรแกรมนี้เหมือนกับโปรแกรมที่ 8-2 เพียงแต่เมื่อพบว่าชื่อและรหัสสมาชิกถูกต้อง ให้สร้าง
ตัวเก็บข้อมูลชื่อ isLoggedin ขึ้นมาโดยกำหนดให้มีค่าเท่ากับ yes ด้วยคำสั่ง setAttribute()
ตัวเก็บข้อมูลนี้จะคงอยู่ตราบเท่าที่ผู้เยี่ยมชมผู้นี้ยังไม่ปิดการทำงานของเบราเซอร์
คราวนี้เวบหน้าใดก็ตามที่เราไม่ต้องการให้ผู้เยี่ยมชมดูได้โดยไม่ล็อกอินก่อน ก็สามารถ
ตรวจสอบการล็อกอินของผู้ที่เข้ามาด้วยการใช้แมธธอส getAttribute() เพื่อตรวจดูว่า
session ของผู้เยี่ยมชมรายนั้นๆ มีตัวเก็บข้อมูลชื่อ isLoggedin อยู่หรือไม่ และมีค่าเท่ากับ
yes หรือเปล่า
ลองสร้างไฟล์ .jsp ขึ้นมาไฟล์หนึ่งโดยสมมติว่าเป็นเวบเพจหน้าที่ต้องการมีการล็อกอินก่อน
ซึ่งจะดูได้ ดังนี้


<% String isLoggedin = new String();
if (session.getAttribute(“isLoggedin”)!=null) isLoggedin =
(String)session.getAttribute(“isLoggedin”);
%>
<html>
<title>Sample Page</title>
<body>
<% if (isLoggedin.equals(“yes”)) { %>
Welcome. You are authorized to view this page. <br>
The money in your account is now $500.00.
<% } else { %>
Sorry. You haven’t logged in.<br>
<a href=”login03.jsp”>Click here to log in.</a>
<% } %>
</body>
</html>

ในส่วนต้นของโปรแกรมนี้เป็นการตรวจสอบดูว่ามีตัวเก็บข้อมูลของ session ที่ชื่อ
isLoggedin อยู่หรือไม่ ถ้ามี ให้รับค่าของมันมาใส่ไว้ในตัวแปรสตริงชื่อเดียวกัน จากนั้นทำ
การตรวจสอบดูว่ามีค่าเป็น yes หรือไม่ ถ้าใช่ก็ให้แสดงเวบเพจหน้านั้น แต่ถ้าไม่ ก็ให้เตือน
ผู้เยี่ยมชมว่ายังไม่ได้ล็อกอินแทน
ลองสร้างไฟล์ชื่อ login03.jsp ขึ้นมาโดยมีเนื้อหาเหมือนโปรแกรมที่ 8-1 แต่เปลี่ยนพารา
มิเตอร์ action ให้มีค่าเป็น auth03.jsp ดังนี้

<% String username = new String();
String password = new String();
%>
<html>
<title>Login</title>
<body>
<form method="post" action="auth03.jsp">
Username : <input type="text" name="username" value="<%=username%>"><br>
Password : <input type="password"
name="password"value="<%=password%>"><br>
<input type="submit">
</form>
</body>
</html>

ลองใส่ชื่อ Songkarn และรหัสลับ 12345 ลงไปแล้วคลิก Submit Query มันจะเรียกไฟล์
auth03.jsp มาตอบสนอง

ตอนนี้ session ได้สร้างและเก็บ isLoggedin ที่มีค่าเท่ากับ yes ไว้แล้ว ให้ลองทดสอบโดย
การเรียกไฟล์ sample01.jsp จะได้ผลดังนี้

แต่ถ้าลองปิดเบราเซอร์แล้วเปิดใหม่ แล้วเรียกไฟล์ sample01.jsp อีกที คราวนี้จะพบว่าเข้า
ไม่ได้แล้ว เพราะ isLoggedin ตัวที่มีอยู่ตายไปพร้อมกับการปิดเบราเซอร์ ผู้เยี่ยมชมต้องทำ
การล็อกอินใหม่
แน่นอนระบบล็อกอินจริงๆ มีความซับซ้อนกว่านี้ นี่เป็นเพียงตัวอย่างเพื่อให้เข้าใจว่าเราจะ
ใช้ session จดจำข้อมูลได้อย่างไรเท่านั้น

คุ๊กกี้

คุณคงเคยใช้บริการฟรีหลายๆ อย่างบนอินเตอร์เนต เช่น อีเมล์ หรือฟรีโฮมเพจต่างๆ หรือ
ไม่ก็เคยซื้อหนังสือบนอินเตอร์เนต คุณอาจแปลกใจที่พบว่าเวบไซต์เหล่านั้นสามารถจดจำ
ชื่อ อีเมล์แอดเดรส หรือพาสเวิร์ดของคุณได้ แม้ว่าคุณจะไม่ได้เยี่ยมชมเวบไซต์เหล่านั้นมา
หลายเดือนแล้ว เวบไซต์พวกนี้อาศัยการบันทึกข้อมูลเกี่ยวกับตัวคุณไว้ในไฟล์ขนาดจิ๋วซึ่ง
มันแอบหยอดทิ้งไว้ในฮาร์ดดิสก์ของคุณเวลาที่เข้าเยี่ยมชมเวบไซต์โดยที่คุณไม่รู้ตัว เวลาที่
คุณกลับมาที่เวบไซต์เหล่านี้อีกครั้ง มันจะอ่านไฟล์ที่มันหยอดเอาไว้เพื่อดึงข้อมูลเกี่ยวกับตัว
คุณกลับมา เราเรียกไฟล์ขนาดจิ๋วเหล่านี้ว่า คุ๊กกี้

Cookie
คุ๊กกี้เป็นวัตถุบนเจเอสพี คลาสที่นิยามคุ๊กกี้ได้แก่คลาส Cookie ซึ่งมีวิธีการตั้งชื่อคุ๊กกี้และ
กำหนดค่าให้กับคุ๊กกี้ด้วยการประกาศวัตถุของคลาสคุ๊กกี้ ตัวอย่างเช่น
Cookie cookie = new Cookie(“name”, “Songkarn”);
เป็นการประกาศวัตถุชื่อ cookie ของคลาส Cookie โดยให้คุ๊กกี้นี้มีชื่อเรียกว่า name และมี
ค่าเท่ากับ Songkarnเวลาเราจะหยอดคุ๊กกี้ลงบนเบราเซอร์ของผู้เยี่ยมชม เราอาศัยแมธธอสของวัตถุแฝง
response ชื่อ addCookie() ซึ่งจะทำให้เบราเซอร์สร้างไฟล์คุ๊กกี้ที่เก็บค่าของคุ๊กกี้เอาไว้บน
ฮาร์ดดิสก์ของผู้เยี่ยมชม แต่ก่อนจะหยอดคุ๊กกี้จำเป็นที่จะต้องกำหนดวันหมดอายุของคุ๊กกี้
ก่อน คุ๊กกี้ทุกอันที่เราหยอดจะมีวันหมดอายุของมันอยู่เพื่อมิให้ข้อมูลในคุ๊กกี้เก่าเกินไป อายุ
ของคุ๊กกี้นับเป็นวินาทีนับจากวินาทีที่หยอดคุ๊กกี้ และเราใช้แมธธอส setMaxAge() ของ
คลาส Cookie ในการกำหนดวันหมดอายุ เช่น
cookie.setMaxAge(60*60*24*30);
เป็นการกำหนดให้คุ๊กกี้ที่ชื่อ cookie มีอายุ 30 วันนับจากวันที่หยอด
ตัวอย่างง่ายๆ สมมติว่าเวบไซต์ของคุณมีระบบสมาชิก ซึ่งทุกครั้งที่ผู้เยี่ยมชมเข้ามาในเวบ
ไซต์จะต้องระบุชื่อสมาชิกและรหัสผ่าน ถ้าผู้เยี่ยมชมเข้ามาทุกวันวันละหลายหน บางทีผู้
เยี่ยมชมอาจรู้สึกรำคาญที่ต้องคอยกรอกชื่อสมาชิกอยู่ตลอดเวลา เราจะลองแก้ปัญหานี้ด้วย
การใช้คุ๊กกี้ในการจดจำชื่อสมาชิกในการกรอกรหัสผ่านครั้งแรกของผู้เยี่ยมชม เพื่อที่ในการ
เยี่ยมชมครั้งต่อไปจะมีชื่อสมาชิกและรหัสเก่าโผล่ออกมารอไว้เลย ผู้เยี่ยมชมเพียงแต่กดปุ่ม
ยืนยันอย่างเดียวก็พอ
เริ่มด้วยการสร้างแบบฟอร์มระบบสมาชิกก่อน

<html>
<title>Login</title>
<body>
<form method=”post” action=”auth01.jsp”>
Username : <input type=”text” name=”username”><br>
Password : <input type=”password” name=”password”><br>
<input type=”submit”>
</form>
</body>
</html>

จากนั้นก็สร้างไฟล์ auth01.jsp ขึ้นมารับมือ ลองดูแบบที่ยังไม่มีคุ๊กกี้ก่อนเพื่อความเข้าใจ

<% String username = request.getParameter(“username”);
String password = request.getParameter(“password”);
%>
<html>
<title>Login</title>
<body>
<% if (username.equals(“Songkarn”)&&password.equals(“12345”)) { %>
Login successful.
<% } else { %>
Login failed.
<% } %>
</body>
</html>

โปรแกรมนี้รับค่า username และ password จากฟอร์มมาเปรียบเทียบ ถ้าชื่อสมาชิกคือ
songkarn และ รหัสผ่านคือ 12345 มันจะแสดงข้อความว่าล็อกอินสำเร็จ มิฉะนั้นจะแสดงข้อ
ความว่าการล็อกอินล้มเหลว (ระบบสมาชิกจริงๆ ซับซ้อนกว่านี้มาก แต่เรายังไม่ขอลงราย
ละเอียด เพราะบทนี้เราสนใจแต่เรื่องการทำคุ๊กกี้)

ที่นี้เราจะเติมคุ๊กกี้ลงไปเพื่อให้ระบบสมาชิกจดจำชื่อสมาชิกที่เคยล็อกอินได้ด้วย เริ่มจากการ
หยอดคุ๊กกี้ก่อนดังนี้

<% String username = request.getParameter("username");
String password = request.getParameter("password");
Cookie cookie = new Cookie("username",username);
cookie.setMaxAge(60*60*24*30);
response.addCookie(cookie);
cookie = new Cookie("password",password);
cookie.setMaxAge(60*60*24*30);
response.addCookie(cookie);
%>
<html>
<title>Login</title>
<body>
<% if (username.equals("Songkarn")&&password.equals("12345")) { %>
Login successful.
<% } else { %>
Login failed.
<% } %>
</body>
</html>

โปรแกรมนี้แทนที่จะรับข้อมูลจากฟอร์มมาเฉยๆ ก็จดใส่คุ๊กกี้ลงไปด้วย คุ๊กกี้ทั้งสองตัวจะมี
อายุอยู่บนเครื่องคอมพิวเตอร์ของนายสงกรานต์เป็นเวลา 30 วัน
คราวนี้ก็มาแก้ฟอร์มสมาชิกใหม่ให้มองหาคุ๊กกี้ในเครื่องคอมพิวเตอร์ก่อน ถ้าพบคุ๊กกี้ที่มีชื่อ
ว่า username และ password ก็ให้นำมากรอกไว้ในแบบฟอร์มรอไว้ให้เลย ดังนี้

<% String username = new String();
String password = new String();
Cookie[] cookies;
Cookie cookie;
cookies = request.getCookies();
if (cookies!=null) {
for (int i = 0; i < cookies.length; i++) {
cookie = cookies[i];
if ("username".equals(cookie.getName())) {
username = cookie.getValue();
}
if ("password".equals(cookie.getName())) {
password = cookie.getValue();
}
}
}
%>
<html>
<title>Login</title>
<body>
<form method="post" action="auth02.jsp">
Username : <input type="text" name="username" value="<%=username%>"><br>
Password : <input type="password"
name="password"value="<%=password%>"><br>
<input type="submit">
</form>
</body>
</html>

วัตถุแฝง request มีแมธธอสชื่อ getCookies() ซึ่งจะคืนค่าของคุ๊กกี้ทุกตัวในฮาร์ดดิสก์ของผู้
เยี่ยมชมมาให้ในรูปของอะเรย์ Cookies[ ] หน้าที่ของเราก็คือตรวจสอบดูว่ามีคุ๊กกี้ตัวไหน
บ้างที่มีชื่อว่า username หรือ password ถ้าพบก็ให้นำค่าของมันมากำหนดค่าให้กับ ตัว
แปรสตริงที่เราสร้างขึ้นมาชื่อว่า username และ password แมธธอสที่ใช้ในการอ่านชื่อและ
ค่าของคุ๊กกี้ได้แก่ getName() และ getValue() ตามลำดับ เมื่อได้ค่าของ username และ
password ซึ่งเหมือนกับชื่อสมาชิกและรหัสผ่านที่เคยใช้แล้ว เราก็นำค่าของมันมากำหนดให้
เป็นค่าปกติของฟอร์มด้วยการกำหนดให้กับพารามิเตอร์ value เช่นนี้แล้ว หากผู้เยี่ยมชม
กลับเข้ามาตอบคำถามในหน้าเดิมอีก ชื่อเก่าของผู้เยี่ยมชมจะปรากฏขึ้นเองในช่องของชื่อผู้
ตอบคำถาม ทำให้ผู้เยี่ยมชมไม่ต้องเสียเวลากรอกชื่อสมาชิกและรหัสซ้ำอีก


สิ่งที่ควรทราบเกี่ยวกับคุ๊กกี้ก็คือ เวลาเบราเซอร์เก็บคุ๊กกี้ไว้ในฮาร์ดดิสก์มันจะแยกคุ๊กกี้ที่มา
จากเวบไซต์ต่างเวบไซต์ออกจากกันโดยเด็ดขาด นั้นคือคุ๊กกี้ที่มีชื่อซ้ำกันแต่เกิดจากคนละ
เวบไซต์จะไม่ปะปนกัน และเบราเซอร์จะยอมให้เวบไซต์ที่หยดคุ๊กกี้นั้นๆ เท่านั้นเป็นผู้อ่าน
คุ๊กกี้ ไม่มีการใช้งานข้ามเวบไซต์เป็นอันขาด นอกจากนี้เบราเซอร์ยังถือว่าคุ๊กกี้ชื่อเดียวกันที่
มาจากเวบไซต์เดียวกันแต่เวบเพจที่หยอดคุ๊กกี้เป็นคนละโฟลเดอร์ เป็นคุ๊กกี้คนละตัวกัน

บีน

บีน คือโปรแกรมขนาดเล็กบนเวบเซิร์ฟเวอร์ ซึ่งคอยช่วยเหลือไฟล์ .jsp ด้วยการทำงานบาง
อย่างแทนให้ โดยที่ไฟล์ .jsp เพียงแต่ร้องขอความช่วยเหลือจากบีนโดยการส่งพารามิเตอร์
ที่จำเป็นไปให้ บีนก็จะส่งผลลัพธ์ที่ต้องการกลับไปให้ทันที
ประโยชน์สำคัญของบีนคือการลดความยุ่งเหยิงของไฟล์ .jsp งานที่เคยต้องใช้คำสั่งเจเอสพี
เป็นสิบๆ บรรทัด จะลดลงเหลือเพียงคำสั่งร้องขอความช่วยเหลือจากบีนเพียงหนึ่งหรือสอง
บรรทัดเท่านั้น ทำให้ไฟล์ .jsp มีขนาดเล็กลงและดูง่ายขึ้น การทำเช่นนี้มีประโยชน์มาก
เพราะปกติแล้วโปรแกรมเมอร์ภาษาจาวาที่พัฒนาคำสั่งเจเอสพี กับนักออกแบบเวบไซต์ที่ใช้
คำสั่ง HTML มักเป็นคนละคนกัน การลดคำสั่งเจเอสพีในเวบเพจลงด้วยการย้ายมาเขียน
โปรแกรมบนบีนแทน ทำให้การแบ่งงานระหว่างเวบโปรแกรมเมอร์ กับผู้ออกแบบเวบไซต์มี
ความคล่องตัวมากขึ้น
การสร้างบีนก็เหมือนกับการเขียนโปรแกรมภาษาจาวาปกติ คือ ต้องเขียนเป็นไฟล์นามสกุล
.java แล้วนำไปคอมไพล์ให้ได้ไฟล์นามสกุล .class พอจะใช้งานก็นำไฟล์ .class ที่ได้ไปวาง
ไว้บนโฟลเดอร์ WEB-INF ใต้โฟลเดอร์ย่อยที่ชื่อ classes

การเรียกใช้งานบีนโดยตรง

อันที่จริงแล้วเราสามารถสร้างบีนแล้วเรียกแมธธอสของบีนโดยตรงในสคริปเลตได้โดยไม่
ต้องผ่านแท็ก setProperty และ getProperty ตัวอย่างเช่น

<jsp:useBean id=”counter” class=”mybean.Counter” scope=”application” />
<html>
<title>My First JSP</title>
<body>
You are the visitor number <%=counter.getCount()%>.
</body>
</html>

หลังจากเรียกใช้บีนผ่านแท็ก useBean แล้ว เราสามารถเรียกแมธธอส getCount() ของบีน
ผ่านชื่อ counter ได้โดยตรงราวกับว่าเป็นวัตถุที่เราสร้างขึ้นกับมือ โปรแกรมข้างต้นให้ผล
เหมือนกับโปรแกรมที่ 7-2 ทุกประการ
อย่างไรก็ตาม ขอแนะนำให้พยายามใช้งานบีนผ่านแท็กเจเอสพีจะดีกว่า เพราะโปรแกรมจะ
ดูเป็นระบบมากกว่า ตอนนี้อาจจะยังมองไม่เห็นภาพอย่างชัดเจน เพราะโปรแกรมตัวอย่างที่
ผ่านมายังไม่ค่อยซับซ้อน แต่ต่อไปจะเห็นชัดขึ้นตอนที่นำไปประยุกต์ใช้งานจริง

แท็กเจเอสพี

ยุคนี้กระแสของ XML มาแรง คำว่า XML ย่อมาจาก Extensible Markup Language เป็น
ภาษาที่มีโครงสร้างคล้ายๆ กับภาษา HTML คือประกอบด้วยแท็กต่างๆ ปะปนกับภาษา
มนุษย์ จุดประสงค์หลักของ XML คือใช้เป็นภาษากลางระหว่างเซิร์ฟเวอร์ต่างชนิดต่างยี่ห้อ
กันให้สามารถรับส่งข้อมูลระหว่างกันได้ โดยไม่ต้องสนใจว่าเซิร์ฟเวอร์เหล่านั้นจะใช้
เทคโนโลยีของค่ายไหน
คำสั่งเจเอสพีได้รับอิทธิพลของ XML ด้วยเหมือนกัน กล่าวคือ เจเอสพีมีสิ่งที่เรียกว่า แท็ก
เจเอสพี ซึ่งเป็นคำสั่งเจเอสพีที่อยู่ในรูปของแท็ก XML โดยจะนำหน้าด้วยแท็ก <jsp: และ
ต่อท้ายด้วย /> เพื่อบอกให้ทราบว่าเป็น แท็กเจเอสพี เราสามารถบอกให้เวบเซิร์ฟเวอร์ทำ
อะไรหลายๆ อย่างได้ด้วยแท็กเจเอสพีเหล่านี้ ในบทนี้เราจะมาดูว่าแท็กเจเอสพีมีอะไรบ้าง

include
คงยังจำได้ว่าถ้าเราต้องการสอดแทรกเนื้อหาในไฟล์อื่นเข้าไปในไฟล์ .jsp ของเรา เราใช้ได
เร็กทีฟ include ข้อเสียของการสอดแทรกเนื้อหาของไฟล์อื่นด้วยวิธีนี้คือ ถ้ามีการแก้ไขไฟล์
ต้นทาง เนื้อหาใหม่จะไม่ไปปรากฏอยู่ในไฟล์ปลายทางโดยอัตโนมัติ เพราะการสอดแทรก
เกิดขึ้นเมื่อตอนที่มีผู้เยี่ยมชมไฟล์ปลายทางเพียงครั้งเดียวเท่านั้นเจเอสพีมีแท็กเจเอสพีที่
ทำงานได้เหมือนกับไดเร็กทีฟ include แต่จะอัพเดทไฟล์ปลายทางโดยอัตโนม้ติเวลาที่มีการ
แก้ไขไฟล์ต้นทาง แท็กนี้คือ <jsp:include ลองดูรูปแบบของคำสั่งจากตัวอย่างต่อไปนี้

 <html>
<title> Test Page </title>
<body>
<jsp:include page=”logo.html” flush=”true” />
<br>
This is a test page.
</body>
</html>


 หน้าของไฟล์ includetag.jsp จะเปลี่ยนตามโดยอัตโนมัติ
แท็ก <jsp: include ต้องมีพารามิเตอร์ flush=”true” อยู่ด้วยเสมอ

forward
แท็ก forward มีไว้สำหรับส่งผู้เยี่ยมชมไปยังเวบหน้าอื่น ตัวอย่างเช่น สมมติว่าเราสร้างไฟล์
ชื่อ forward.jsp ขึ้นมา แล้วกำหนดให้เมื่อไรก็ตามที่มีผู้เข้ามาเยี่ยมชมเวบเพจหน้านี้ ให้เวบ
เซิร์ฟเวอร์ส่งผู้เยี่ยมชมยัง includetag.jsp แทน เราทำได้ดังนี้

<html>
<title> Forward Page </title>
<body>
<jsp:forward page=”includetag.jsp” />
<br>
You will be forward to includetag.jsp.
</body>
</html>

ถ้าลองเข้าถึงเพจนี้ดูจะพบว่าเบราเซอร์จะกระโดดไปยังเพจ includetag.jsp ในทันที

ใช้แท็กเจเอสพีแทนไดเร็กทีฟ
เราสามารถใช้แท็กเจเอสพีแทนการใช้ไดเร็กทีฟ page หรือ include ได้ด้วย โดยมีรูปแบบ
ดังตัวอย่างต่อไปนี้
<jsp:directive.page import=”java.util.*” />
ตัวอย่างนี้ให้ผลเหมือนกับคำสั่ง
<%@ page import=”java.util.*” %>
ทุกประการ
ถ้าเป็นไดเร็กทีฟ include ก็เพียงแต่ใช้คำว่า include แทน page เช่น
<jsp:directive.include file=”hello.html” />
ให้ผลเหมือนกับคำสั่ง
<%@ include file”hello.html” %>
ทุกประการ

วัตถุแฝง

จาวาเป็นภาษาเชิงวัตถุ การจะใช้งานแมธธอสจะต้องเริ่มจากการประกาศวัตถุของคลาสที่มี
แมธธอสนั้นอยู่ขึ้นมาก่อน แล้วจึงเรียกใช้แมธธอสนั้นผ่านทางวัตถุที่เราประกาศขึ้น
สำหรับเจเอสพี คลาสบางครั้งมีความจำเป็นที่จะต้องใช้งานบ่อยมาก ดังนั้นเจเอสพีจึงลดขั้น
ตอนลงด้วยการสร้างวัตถุของคลาสเหล่านั้นขึ้นมาให้เราเรียกใช้แมธธอสได้ทันทีโดยไม่ต้อง
เขียนคำสั่งประกาศวัตถุเหล่านั้นก่อน เราเรียกวัตถุพวกนี้ว่า วัตถุแฝง
ในบทนี้เราจะมาเรียนรู้ว่าวัตถุแฝงมีอะไรบ้าง แต่ก่อนอื่นขออธิบายความหมายของคำว่า
scope ซึ่งจำเป็นต่อการทำเข้าใจเรื่องวัตถุแฝงก่อน

scope
scope หมายถึงช่วงชีวิตของวัตถุมีสี่ระดับ ได้แก่

  • application เกิดขึ้นและคงอยู่ตลอดไปตราบเท่าที่เวบเซิร์ฟเวอร์ยังทำงานอยู่
  • sessionเกดิ ขึ้นเมื่อผเู้ย่ยี มชมใชเ้บราเซอร์ตดิ ตอ่ เขา้มาในเวบไซต์ และคงอยตู่ ราบเทา่ท่เี บรา
    เซอร์ของผู้เยี่ยมชมยังไม่หยุดทำงาน
  • request เกดิ ขึ้นเมื่อผเู้ย่ยี มชมเขา้ถงีเพจหนา้หน่งึๆ และจบลงทนั ทเีมื่อเบราเซอร์แสดงผลของ
    เพจนั้นออกหน้าจอเรียบร้อยแล้ว ถ้าเพจนั้นๆ ประกอบด้วยไฟล์ .jsp หลายๆ ไฟล์ (มีการ
    ใช้ไดเร็กทีฟ include) จะถือว่าไฟล์ .jsp ทุกไฟล์ที่ประกอบขึ้นเป็นเพจนั้นอยู่ใน
    request เดียวกัน
  • page เกิดขึ้นเมื่อผู้เยี่ยมชมเข้าถีงเพจหน้าหนึ่งๆ และจบลงทันทีเมื่อเบราเซอร์แสดงผลของ
    เพจนั้นออกหน้าจอเรียบร้อยแล้ว ถ้าเพจนั้นๆ ประกอบด้วยไฟล์ .jsp หลายๆ ไฟล์ (มีการ
    ใช้ไดเร็กทีฟ include) จะถือว่าไฟล์ .jsp แต่ละไฟล์ที่ประกอบขึ้นเป็นเพจนั้นเป็นคนละ
    page
request

วัตถุแฝงตัวแรกที่เราจะทำความรู้จักคือ request ซึ่งเป็นวัตถุแฝงของคลาส
HttpServletRequest วัตถุแฝงที่ชื่อ request นี้มี scope เป็นแบบ request ด้วยกล่าวคือ ใน
การเยี่ยมชมแต่ละครั้งวัตถุแฝง request จะถูกสร้างขึ้นและจะตายไปทันทีที่การเยี่ยมชมสิ้น
สุดลง
วัตถุแฝง request มีแมธธอสดีๆ ที่เป็นประโยชน์จำนวนมาก แมธธอสตัวแรกคือ
getHeader() ซึ่งใช้สืบค้นค่าพารามิเตอร์ต่างๆ ของเบราเซอร์ของผู้เยี่ยมชม ตัวอย่างต่อไป
นี้เป็นตัวอย่างการเรียกใช้แมธธอส getHeader()


<html>
<title>Request Information</title>
 <body>
Browser : <%= request.getHeader(“User-Agent”) %> <br>
Cookies : <%= request.getHeader(“Cookie”) %> <br>
Accepted MIME types? : <%= request.getHeader(“Accept”) %> <br>
Language accepted : <%= request.getHeader(“Accept-Language”) %> <br>
Host : <%= request.getHeader(“Host”) %> <br>
Connection : <%= request.getHeader(“Connection”) %> <br>
</body>
</html>


 เพจนี้จะแสดงข้อมูลต่างๆ ของการร้องขอของเบราเซอร์ เช่น ชนิดของเบราเซอร์ ภาษาปกติ
ที่เบราเซอร์แปลผล เป็นต้น ข้อมูลเหล่านี้เป็นข้อมูลซึ่งปกติจะส่งมากับเนื้อความของเพจ
โดยจะอยู่ที่ส่วนหัวของไฟล์ เราเรียกข้อมูลกลุ่มนี้ว่า Header ดังนั้นเราใช้แมธธอสของวัตถุ
request ที่ชื่อ getHeader() ในการเรียกข้อมูลแต่ละตัวออกมา จะเห็นได้ว่าเราสามารถเรียก
ใช้วัตถุแฝง request นี้ได้ทันทีที่เมื่อไรก็ได้ราวกับว่ามีใครสร้างมันเอาไว้ให้เรา

การตอบสนองแบบฟอร์มของผู้ใช้

ประโยชน์ที่สำคัญอย่างยิ่งของวัตถุแฝง request คือการตอบสนองแบบฟอร์มของผู้ใช้ที่สร้าง
จากคำสั่ง <form> ของ HTML ตัวภาษา HTML เองตอบสนองไม่ได้เพราะการตอบ
สนองฟอร์มต้องทำบนฝั่งเซิร์ฟเวอร์ วัตถุแฝง request มีแมธธอสชื่อ getParameter() เป็น
อุปกรณ์สำคัญในการตอบสนองแบบฟอร์ม
ลองดูตัวอย่างการตอบสนองแบบฟอร์มของผู้ใช้ด้วยการสร้างแบบฟอร์มที่ใช้แทนปฏิทินร้อย
ปี ด้วยการให้ผู้เยี่ยมชมกรอกวันเดือนปีเกิดแล้วเครื่องจะแสดงวันของสัปดาห์ และปีนักษัตร
ของผู้เยี่ยมชม
เริ่มต้นด้วยการสร้างไฟล์ .html ง่ายๆ ซึ่งรับชื่อและวันเดือนปีเกิด

<html>
<title>100-year Caledar</title>
<body>
<form method=”post” action=”result.jsp” >
ชื่อ <input type=”text” name=”name”><br>
วันที่เกิด
<input type=”text” name=”date” size=”2” maxlength=”2”>
เดือน
<select name="month">
<option value="1" >มกราคม</option>
<option value="2" >กุมภาพันธ์</option>
<option value="3" >มีนาคม</option>
<option value="4" >เมษายน</option>
<option value="5" >พฤษภาคม</option>
<option value="6" >มิถุนายน</option>
<option value="7" >กรกฎาคม</option>
<option value="8" >สิงหาคม</option>
<option value="9" >กันยายน</option>
<option value="10" >ตุลาคม</option>
<option value="11" >พฤศจิกายน</option>
<option value="12" >ธันวาคม</option>
</select>
ปี พ.ศ.
<input type=”text” name=”year” size=”4” maxlength=”4”><br>
<input type=”submit”>
</form>
</body>
</html>


 คราวนี้ก็สร้างไฟล์ .jsp ชื่อ result.jsp ขึ้นมารับมือ ดังนี้

<%@ page import="java.util.Date" %>
<%@ page import="java.text.SimpleDateFormat" %>
<%! String[] zodiac = {“วอก","ระกา","จอ","กุน","ชวด","ฉลู",
"ขาล","เถาะ","มะโรง","มะเส็ง","มะเมีย","มะแม"};
String[] dayOfWeek ={"","อาทิตย์","จันทร์","อังคาร","พุธ",
"พฤหัสบดี","ศุกร์","เสาร์"};
%>
<%
String name = request.getParameter("name");
String date = request.getParameter("date");
String month = request.getParameter("month");
String thaiyear = request.getParameter("year");
int year = Integer.parseInt(thaiyear)-543;
int y = year%12;
SimpleDateFormat formatter = new SimpleDateFormat("d-M-yyyy");
Date birthdate = formatter.parse(date+"-"+month+"-"+year);
formatter = new SimpleDateFormat("F");
int day = Integer.parseInt(formatter.format(birthdate));
%>
<html>
<title>100-year Caledar</title>
<body>
คุณ <%=name%> เกิดวัน <%=dayOfWeek[day]%> ปี <%=zodiac[y]%>
</body>
</html>

พารามิเตอร์ของแมธธอส getParameter() คือ ชื่อของข้อมูลที่ส่งมาจากฟอร์มซึ่งตรงกับค่า
ของพารามิเตอร์ name ของฟอร์มแต่ละตัวนั่นเอง เมื่อเรารับข้อมูลอันได้แก่ ชื่อ และวัน
เดือน ปีมาแล้ว เราก็นำมาคำนวณหาวันของสัปดาห์ และปีนักษัตร ผลลัพธ์ที่ได้เป็นดังนี้

response

response เป็นวัตถุแฝงของคลาส HttpServletResponse ใช้จัดการเกี่ยวกับการตอบสนอง
การร้องขอไฟล์ .jsp นั้นๆ มี scope เป็นแบบ request และมีแมธธอสที่น่าสนใจดังนี้
 sendRedirect()
ใช้ส่งผู้เยี่ยมชมไปยังเพจอื่นทันที เช่น ต้องการส่งผู้เยี่ยมชมจากเพจปัจจุบันไปยัง
http://www.yahoo.com ทำได้โดยใช้คำสั่ง
<% response.sendRedirect(http://www.yahoo.com); %>
 sendError()
ใช้บอกให้เบราเซอร์แสดง Error เช่น
<% response.sendError(500); %>
ใช้เรียก Error 500


session

session เป็นวัตถุแฝงของคลาส HttpSession มี scope เป็นแบบ session กล่าวคือมันจะ
ถูกสร้างขึ้นเมื่อผู้เยี่ยมชมใช้เบราเซอร์คลิกเข้ามาในเวบไซต์เป็นครั้งแรก หนึ่งตัวต่อหนึ่งผู้
เยี่ยมชม และจะอยู่ตราบเท่าที่เบราเซอร์ยังไม่จบการทำงาน วัตถุแฝง session ช่วยทำให้
เวบเซิร์ฟเวอร์จำผู้เยี่ยมชมได้เพราะทุกครั้งที่เวบเซิร์ฟเวอร์สร้าง session มันจะกำหนด
sessionID เป็นหมายเลขกำกับ session ขึ้นมา เวบเซิร์ฟเวอร์จะอาศัย sessionID ในการ
จดจำว่าการร้องขอที่ส่งเข้ามาเป็นการร้องขอที่มาจากเบราเซอร์ตัวใด ซึ่งทำให้เวบไซต์ของ
เราติดตามพฤติกรรมของผู้เยี่ยมชมแต่ละรายได้ตลอดเวลาที่ผู้เยี่ยมชมยังอยู่ภายในเวบไซต์

page

วัตถุแฝงตัวนี้มี scope เป็น
แบบ page

out
out เป็นวัตถุแฝงของคลาส Writer หน้าที่ของ out คือการสั่งให้เบราเซอร์แสดงข้อความ
อะไรก็ได้ทั้งที่คำสั่งนี้อยู่ภายในสคริปเลต

config
วัตถุแฝง config มีแมธธอสที่น่าสนใจอยู่หนึ่งตัวคือ getServletName() ซึ่งจะแสดงค่าของ
โฟล์เดอร์ที่เก็บไฟล์ .class ของเวบหน้านั้น

pageContext
pageContext รวบรวมข้อมูลทั้งหมดเอาไว้ในตัวเดียวกัน หมายความว่าคุณสามารถเข้าถึง
ข้อมูลใดๆ ของ session, page, config, application เข้าถึงได้ด้วย pageContext เพราะมัน
มีแมธธอสอยู่อย่างมากมายไว้ให้ใช้ แต่การใช้งานย่อมซับซ้อนกว่า เราจะไม่ขอกล่าวถึงในที่
นี้

exception
exception เป็นวัตถุแฝงที่เก็บข้อมูลเกี่ยวกับบั๊กต่างๆ ที่เกิดขึ้น

ไดเร็กทีฟ

ไดเร็กทีฟไม่ใช่คำสั่งในภาษาจาวา แต่เป็นคำสั่งที่บอกให้เวบเซิร์ฟเวอร์ทำอะไรบางอย่าง
ก่อนที่จะรันคำสั่งเจเอสพีที่อยู่ในเพจ ไดเร็กทีฟมักอยู่ที่ส่วนบนสุดของไฟล์ .jsp และล้อม
รอบด้วยเครื่องหมาย <%@ และ %> ซึ่งทำให้ดูคล้ายกับบล็อกของคำสั่งเจเอสพี ในบทนี้
เราจะทำความรู้จักกับไดเร็กทีฟสองกลุ่มคือ include และ page


ไดเร็กทีฟ include

ไดเร็กทีฟ include มีไว้สำหรับสอดแทรกเนื้อหาของเวบหน้าอื่นเข้าไปในเวบหน้าปัจจุบัน
ตัวอย่างการใช้งานที่เห็นได้ชัดก็คือ การสอดแทรกเมนูหลักหรือโลโก้ต่างๆ ที่ส่วนต้นของ
เวบเพจทุกเพจบนเวบไซต์ ข้อดีของการทำแบบนี้ก็คือเราเขียนเมนูหลักหรือโลโก้เหล่านั้น
เพียงครั้งเดียวบนเพจหน้าหนึ่ง แล้วสามารถนำไปแทรกลงในเวบหน้าอื่นๆ ได้ด้วยการ
แทรกเพียงคำสั่งไดเร็กทีฟสั้นๆ ลงไป


ไดเร็กทีฟ page

ไดเร็กทีฟ page เป็นไดเร็กทีฟที่มีที่ใช้บ่อยกว่าไดเร็กทีฟ include และมีพารามิเตอร์อยู่
หลายตัว ในบทที่แล้วเราได้เคยใช้ไดเร็กทีฟนี้ไปแล้วในการอิมพอร์ตแพจเกจซึ่งใช้พารา
มิเตอร์ import ในการระบุชื่อของแพจเกจที่ต้องการอิมพอร์ต พารามิเตอร์ตัวอื่นๆ ของได
เร็กทีฟ page ก็ได้แก่

language
พารามิเตอร์นี้ใช้บอกเวบเซิร์ฟเวอร์ว่าคำสั่งในบล็อกเจเอสพีที่ตามมาในเพจนั้นๆ เขียนด้วย
ภาษาคอมพิวเตอร์ภาษาใด ซึ่งค่าที่เป็นไปได้ของพารามิเตอร์ตัวนี้ในขณะนี้มีแค่ตัวเดียวคือ
java ซึ่งเป็นค่าปกติของมันอยู่แล้ว ไดเร็กทีฟนี้จึงอาจจะละไว้ไม่ใส่ก็ได้ ลักษณะการเขียนก็
เป็นดังต่อไปนี้
<%@ page language=”java” %>

contentType
เวลาเบราเซอร์รับข้อมูลจากเวบเซิร์ฟเวอร์มาแสดงผล ข้อมูลที่เวบเซิร์ฟเวอร์ส่งมามีลักษณะ
เป็นไฟล์ เช่น ไฟล์ .html ไฟล์ .gif ไฟล์ .class เป็นต้น เบราเซอร์ต้องอาศัยพารามิเตอร์
contentType ในการแยกแยะว่าไฟล์ที่ได้รับมาใช้ทำอะไร มีอะไรอยู่ในนั้น เราสามารถมา
บอกเบราเซอร์ของผู้เยี่ยมชมได้ว่าไฟล์ .jsp ที่ส่งมาให้เป็นคำสั่ง HTML ล้วนๆ ด้วยการใช้
พารามิเตอร์ contentType ดังนี้
<%@ page contentType=”text/html” %>
อย่างไรก็ตาม พารามิเตอร์นี้ก็ไม่จำเป็นอีกเช่นกัน เพราะปกติเบราเซอร์จะคิดว่าเป็นไฟล์
HTML อยู่แล้ว กรณีที่จะใช้พารามิเตอร์ตัวนี้จริงๆ ก็คือ กรณีที่มีภาษาไทยอยู่ในหน้าเวบ
ของเรา เราต้องการบอกให้เบราเซอร์เข้ารหัสภาษาให้ถูกต้อง เราทำได้โดยการใส่ไดเร็กทีฟ
ดังนี้
<%@ page contentType=”text/html;char-set=windows-874” %>
windows-874 เป็นการเข้ารหัสมาตรฐานของภาษาไทยบนอินเตอร์เนตเอ็กซ์พลอเลอร์ ถ้า
เราใส่ไดเร็กทีฟนี้ไว้ในเพจที่มีภาษาไทย ผู้เยี่ยมชมจะสามารถอ่านภาษาไทยได้เลยไม่จำ
เป็นต้องเสียเวลาในการเปลี่ยน encoding ให้เป็นภาษาไทยด้วยตนเอง

info
พารามิเตอร์ตัวต่อไปคือ info ซึ่งมีไว้เก็บข้อความอะไรก็ได้ที่ผู้เขียนต้องการสื่อให้กับเบรา
เซอร์ เบราเซอร์สามารถเรียกข้อความใน info ออกมาแสดงผลได้ด้วยคำสั่ง
(HttpJspPage)page.getServletInfo()

buffer
พารามิเตอร์ buffer มีไว้สำหรับกำหนดขนาดแรมชั่วคราวที่เวบเซิร์ฟเวอร์ใช้เก็บผลลัพธ์ที่ได้
จากเจเอสพีคอนเทนเนอร์เวลารันเพจนั้นๆ ค่าปกติของมันคือ 8kb ซึ่งเพียงพอสำหรับเวบ
เพจทั่วไป ในกรณีที่เราต้องการประหยัดแรมเราสามารถลดขนาดของบัฟเฟอร์ต่อเพจลง
และในทางตรงกันข้ามถ้าเรามีเวบเพจบางเพจที่มีความยาวของเนื้อหามากกว่าที่บัฟเฟอร์
ขนาด 8kb จะรับได้ เราต้องขยายขนาดเพื่อให้เนื้อหาในเพจถูกแสดงอย่างครบถ้วน ดังตัว
อย่างต่อไปนี้
<%@ page buffer=”32kb” %>
ตัวอย่างข้างต้นขยายขนาดของบัฟเฟอร์เป็น 32 กิโลไบต์ต่อเพจ

autoFlush
พารามิเตอร์ autoFlush ใช้บอกว่าให้เวบเซิร์ฟเวอร์ทำอย่างไรเมื่อแรมที่ใช้เป็นบัฟเฟอร์เต็ม
ค่าปกติของ autoFlush คือ “true” ซึ่งเป็นการบอกให้ลบข้อมูลเก่าๆ ในแรมทิ้งเพื่อให้บัฟ
เฟอร์สามารถมีเนื้อที่ใหม่ๆ สำหรับทำงานต่อไปได้ แต่ถ้าเราใส่ข้อความต่อไปนี้ลงในไฟล์
.jsp ของเรา
<%@ page autoFlush=”false” %>
เมื่อใช้งานเวบเซิร์ฟเวอร์ไปนานๆ จนเนื้อที่ในบัพเฟอร์เต็ม การเข้าถึงเวบเพจจากผู้เยื่ยมชม
รายต่อไปจะทำให้เกิด error ขึ้น
โดยปกติก็ไม่มีเหตุผลอันใดที่คุณจะเซตพารามิเตอร์ autoFlush ให้เป็น false

extends
โดยปกติแล้วคลาสที่เกิดจากไฟล์ .jsp จะต้องสืบทอดคลาส HttpJspBase ถ้าเราต้องการให้
มันสืบทอดคลาสที่เราสร้างขึ้นเองเราสามารถใส่ชื่อของคลาสแม่เป็นค่าของพารามิเตอร์
extends ทั้งนี้คลาสที่เราสร้างขึ้นเองต้องสืบทอดคลาส HttpJspBase มาก่อนและต้องมี
แมธธอสนามธรรมชื่อ _jspService() อยู่ นอกจากนี้เราต้องคอมไพล์คลาสที่เราสร้างขึ้นเอง
ให้เป็นไฟล์ .class และเก็บไว้ในโฟลเดอร์ WEB-INF ใต้โฟลเดอร์ ROOT
ในที่นี้ไม่ขอยกตัวอย่างการสืบทอดคลาสส่วนตัวเพราะไม่เป็นที่นิยมใช้ และอาจเกิดความผิด
พลาดได้ง่าย

isThreadSafe
โดยปกติไฟล์ .jsp สามารถถูกเข้าถึงได้โดยผู้เยี่ยมชมมากกว่าหนึ่งคนในเวลาเดียวกัน
เพราะ Tomcat สนับสนุนการทำงานแบบมัลติเทรด มัลติทาส์กกิ้ง แต่ในบางกรณีเรา
ต้องการกันไม่ให้มีการเข้าถึงเพจหน้าเดียวกันจากผู้ใช้มากกว่าหนึ่งคนในเสียววินาทีเดียว
กันเช่น เพจที่ทำงานเกี่ยวกับระบบการเงินของธนาคารหรือระบบจองตั๋วเครื่องบินที่จะมั่วไม่
ได้เป็นอันขาด เราใช้พารามิเตอร์ isThreadSafe ในการสั่งให้ Tomcat ล็อกเพจนี้ไว้ให้เข้า
ถึงได้ทีละหนึ่งคนด้วยการกำหนดค่าให้เป็น false ดังนี้
<%@ page isThreadSafe=”false” %>

session
เวบเซิร์ฟเวอร์ที่สนับสนุนเจเอสพี มีการจดจำเบราเซอร์ที่เข้าถึงเวบเพจของมันด้วย เรา
เรียกการติดต่อมาจากเบราเซอร์ตัวเดียวกันว่า session ไม่ว่าเบราเซอร์นั้นจะเข้าถึงเพจกี่
เพจ ตราบใดที่เบราเซอร์นั้นยังไม่หยุดการทำงานเวบเซิร์ฟเวอร์จะจดจำได้ว่าเป็นการเข้าถึง
จากเบราเซอร์ตัวเดิม การจดจำ session ทำให้เวบเซิร์ฟเวอร์ต้องทำงานมากขึ้นกว่าปกติ
เพราะต้องคอยติดตามตรวจสอบเบราเซอร์ เราสามารถบอกให้ Tomcat ไม่ต้องตรวจสอบ
session ได้ด้วยการสั่ง
<%@ page session=”false” %>

บล็อกของคำสั่งเจเอสพี

ในบทนี้คุณจะได้เรียนรู้วิธีการสร้างไฟล์ .jsp เพื่อใช้สร้างโฮมเพจของคุณด้วยการเขียนไฟล์
.jsp ไฟล์แรกในชีวิต ไฟล์นี้มีความสามารถพิเศษคือการนับจำนวนผู้ที่เคยเข้าเยี่ยมชมตัวมัน
เองได้
การสร้างไฟล์ .jsp
การสร้างไฟล์ .jsp ทั่วไปเริ่มจากการใช้ Notepad ในการสร้าง ตอนนี้ให้คุณสร้างไฟล์ชื่อ
counter01.jsp แล้วพิมพ์ข้อความต่อไปนี้ลงไป

ผลที่ได้ควรจะเป็นดังนี้


ถ้าลองรีเฟรชเบราเซอร์ดูหลายๆ ครั้ง จะเห็นได้ว่าหมายเลขผู้เยี่ยมชมเพิ่มขึ้นได้เองทีละ
หนึ่ง การรีเฟรชเปรียบได้กับการร้องขอโฮมเพจหน้านี้ซ้ำใหม่


บล็อกเจเอสพี

เราทราบแล้วว่าบล็อกของคำสั่งเจเอสพีล้อมรอบด้วยเครื่องหมาย <% และ %> ที่จริงแล้ว
บล็อกเจเอสพียังแบ่งออกได้อีกเป็นสามประเภท ได้แก่ บล็อกประกาศตัวแปร บล็อกแสดง
ค่าของตัวแปร และบล็อกของสคริปเลต เครื่องหมายอัศเจรีย์ และเครื่องหมายเท่ากับ ที่อยู่
หลังเครื่องหมาย <% ในโปรแกรมที่ 3-1 ล้วนเป็นสิ่งที่ใช้แยกความแตกต่างระหว่างบล็อกเจ
เอสพีแต่ละประเภทบล็อกของคำสั่งเจเอสพีมีหลายประเภท ดังต่อไปนี้

บล็อกประกาศตัวแปร

บล็อกประกาศตัวแปรคือบล็อกเจเอสพีที่ถูกล้อมด้วยเครื่องหมาย <%! และ %> คำสั่งเจเอส
พีที่อยู่ภายในบล็อกประกาศตัวแปรต้องเป็นคำสั่งประกาศตัวแปรหรือแมธธอสในภาษาจาวา
และอาจมีมากกว่าหนึ่งคำสั่งก็ได้ ตัวอย่างของบล็อกประกาศตัวแปรที่ผ่านมาแล้วใน
โปรแกรมที่ 3-1 ได้แก่
<%! int count = 0; %>
คำสั่งในบล็อกนี้เป็นการประกาศตัวแปรจำนวนเต็มชื่อ count และกำหนดให้มีค่าเริ่มต้นเป็น
0 โปรดสังเกตว่าต้องจบคำสั่งด้วยเครื่องหมาย ; เสมอตามหลักภาษาจาวาทั่วไป ถ้าต้องการ
ประกาศตัวแปรมากกว่าหนึ่งตัวก็สามารถทำได้เช่น
<%! int i = 0;
double j = 0.0;
%>
แบบนี้เป็นการประกาศตัวแปรสองตัวในบล็อกประกาศตัวแปรบล็อกเดียว คือ ตัวแปร
จำนวนเต็ม i และ ตัวแปรทศนิยมแบบยาว j โดยกำหนดให้มีค่าเริ่มต้นเท่ากับ 0 ทั้งคู่
นอกจากการประกาศตัวแปรแล้ว บล็อกประกาศตัวแปรยังใช้ประกาศแมธธอสได้อีกด้วย
เช่น
<%! int square(int i) {
return i*i;
}
%>
ตัวอย่างนี้เป็นการประกาศแมธธอสชื่อ square() ซึ่งสามารถคำนวนค่ายกกำลังสองของเลข
จำนวนเต็มให้เราได้ เราสามารถเรียกใช้แมธธอส square() นี้ที่ใดก็ได้ในไฟล์ .jsp ของเรา
เสมือนเป็นแมธธอสช่วยเหลือ


บล็อกแสดงค่าตัวแปร

บล็อกแสดงค่าตัวแปร คือ บล็อกเจเอสพีที่ล้อมรอบด้วยเครื่องหมาย <%= และ %> ดังใน
โปรแกรมที่ 3-1 ข้างต้นมีบล็อกแสดงค่าตัวแปรอยู่หนึ่งบล็อกได้แก่
<%= ++count %>
คำสั่งในบล็อกนี้อาจเป็นได้ทั้งตัวแปร แมธธอส หรือวัตถุต่างๆ ซึ่งมีค่าในตัวของมันเอง เวลา
เจเอสพี คอนเทนเนอร์เจอบล็อกแสดงค่าตัวแปร มันจะแสดงค่าของตัวแปร แมธธอส หรือ
วัตถุนั้นๆ ในตำแหน่งนั้นออกมา เช่นในกรณีข้างต้นคำสั่งนี้เป็นการบอกให้บวกค่าปัจจุบัน
ของตัวแปร count ด้วยหนึ่ง แล้วแสดงค่าของตัวแปร count สิ่งที่ได้คือเบราเซอร์จะแสดงค่า
ปัจจุบันของตัวแปร count ซึ่งก็คือตัวเลขบอกจำนวนผู้เยี่ยมชมออกมา สังเกตว่าคำสั่งใน
บล็อกนี้ไม่ต้องมีเครื่องหมาย ; ต่อท้าย


บล็อกสคริปเลต

บล็อกเจเอสพีประเภทสุดท้ายได้แก่ บล็อกสคริปต์เลต ซึ่งถูกล้อมรอบด้วยเครื่องหมาย <%
และ %> ธรรมดา

คอมเมนท์ในเจเอสพี

ตอนนี้เราได้เรียนรู้แล้วว่าบล็อกเจเอสพีมีสามแบบคือ บล็อกประกาศตัวแปร บล็อกแสดงค่า
ของตัวแปร และบล็อกสคริปเลต ซึ่งใช้เครื่องหมายกำกับบล็อกต่างกัน ที่จริงแล้วยังมีบล็อก
ของเจเอสพีอีกแบบหนึ่งคือ บล็อกของคอมเมนท์ ซึ่งใช้เครื่องหมาย <%-- และ --%> ล้อม
รอบคอมเมนท์ คอมเมนท์มีไว้ช่วยความจำของผู้เขียนโปรแกรมเองด้วยการเขียนคำอธิบาย
ต่างๆ เวบเซิร์ฟเวอร์จะละเลยข้อความที่อยู่ข้างใน

มารู้จัก เจเอสพี

 เจเอสพี

จาวาเซิร์ฟเวอร์ เพจ™ หรือเรียกย่อๆ ว่า เจเอสพี คือ การใช้ภาษาจาวาในการสร้างเวบ
เพจแบบที่มีเนื้อหาไม่ตายตัว

เจเอสพี
เวบเพจที่เขียนด้วย เจเอสพี มีเนื้อหาที่ไม่ตายตัว โดยคำสั่งเจเอสพีจะอยู่ปะปนกับคำสั่ง
HTML เพื่อสร้างเนื้อหาเฉพาะส่วนที่มีเนื้อหาที่เปลี่ยนแปลงได้ ลองดูตัวอย่างการใช้คำสั่งเจ
เอสพีสร้างโฮมเพจที่สามารถแสดงวันเวลาปัจจุบันซึ่งเปลี่ยนไปเรื่อยๆ ทุกครั้งที่มีผู้เยี่ยมชม
ดังต่อไปนี้

คำสั่ง เจเอสพี ในไฟล์ helloworld.jsp คือ คำสั่ง <%= new java.util.Date() %> ซึ่งเป็น
คำสั่งที่บอกให้แสดงวันที่และเวลา เนื้อหาส่วนอื่นๆ จะเหมือนกันทุกครั้งที่มีผู้เยี่ยมชมเวบ
เพจ แต่ตรงตำแหน่งของคำสั่งเจเอสพี ข้อความจะเปลี่ยนไปเรื่อยๆ เมื่อมีผู้เยี่ยมชมเวบไซต์
เพราะมันจะแสดงวันที่และเวลาปัจจุบัน ณ ขณะที่เยี่ยมชมเวบเพจนั้น ดังภาพ


โฮมเพจนี้มีเนื้อหาต่างกันเมื่อถูกเข้าถึงต่างเวลา นั้นคือเราสามารถใช้ เจเอสพี ในการสร้าง
เนื้อหาส่วนที่ไม่ตายตัวในเวบไซต์ได้ โดยคำสั่งเจเอสพีสามารถอยู่ปะปนกับคำสั่ง HTML
โดยบริเวณที่เป็นคำสั่งเจเอสพีจะล้อมรอบด้วยเครื่องหมาย <% และ %> เสมอ
เวบเพจที่มีคำสั่งเจเอสพีอยู่ จะต้องมีนามสกุล .jsp แทนที่จะเป็น .html ธรรมดา ซึ่งเวบ
เซิร์ฟเวอร์จะดูจากนามสกุลเป็นตัวบอกว่าเวบเพจหน้าใดที่คำสั่งเจเอสพีปนอยู่บ้าง ถ้ามีคำ
สั่งเจเอสพี เวบเซิร์ฟเวอร์จะแทนคำสั่งเจเอสพีในเพจหน้านั้นด้วยข้อความที่เหมาะสมก่อนที่
จะส่งไปให้เบราเซอร์ที่เครื่องของผู้เยี่ยมชมแสดงผล ดังตัวอย่างข้างต้น ทุกครั้งที่มีคนเรียก
เพจ helloworld.jsp เวบเซิร์ฟเวอร์จะแทนคำสั่ง <%= new java.util.Date() %> ด้วยวันที่
และเวลาปัจจุบันก่อน แล้วจึงส่งไปให้เบราเซอร์แสดงผล แต่ถ้าเวบเพจหน้านั้นมีนามสกุล
เป็น .html มันจะส่งไปให้เบราเซอร์ทันที เพราะเนื้อหาของไฟล์ .html นั้นตายตัวอยู่แล้ว ไม่
ต้องเปลี่ยนแปลงอะไร
อนึ่ง การแสดงวันที่และเวลาเป็นเพียงตัวอย่างหนึ่งที่ทำให้เห็นภาพของประโยชน์ของการใช้
คำสั่งเจเอสพี คำสั่งเจเอสพียังทำอะไรต่อมิอะไรได้อีกมาก

ทำไมต้องใช้เจเอสพี

อันที่จริงมีเทคโนโลยีอื่นๆ อีกหลายตัวที่ใช้สร้างโฮมเพจที่มีเนื้อหาแบบไม่ตายตัวได้เหมือน
กับเจเอสพี เช่น CGI, ASP, ColdFusion หรือ PHP เราเรียกเทคโนโลยีเหล่านี้ว่า
เซิร์ฟเวอร์ไซด์สคริปต์ (Server-side scripts) เพราะมีลักษณะคล้ายๆ กับภาษา
คอมพิวเตอร์ ซึ่งสั่งให้เวบเซิร์ฟเวอร์สร้างเวบเพจแบบไม่ตายตัวให้ แต่เจเอสพีมีข้อดีที่เหนือ
กว่าเซิร์ฟเวอร์สคริปต์ตัวอื่นๆ อยู่หลายประการ

ประการแรก เจเอสพี ไม่ใช่ภาษาคอมพิวเตอร์ที่สร้างขึ้นมาใหม่ คำสั่งทุกคำสั่งของเจเอสพี
คือคำสั่งภาษาจาวา ดังนั้นผู้ที่รู้ภาษาจาวาอยู่แล้วจึงเรียนรู้เจเอสพีได้อย่างรวดเร็ว อีกทั้ง
ภาษาจาวายังเป็นภาษาเชิงวัตถุที่มีความสมบูรณ์แบบ มีโครงสร้างภาษาที่รัดกุม และมี
ความปลอดภัยสูง ไม่ยึดติดกับระบบปฏิบัติการ ดังนั้นเวบไซต์ที่เขียนด้วยเจเอสพีจึงได้รับ
อานิสงส์เหล่านั้นไปด้วย
ประการที่สอง เจเอสพี มีสถาปัตยกรรมที่เหมาะกับการใช้งานของผู้เยี่ยมชมจำนวนมากๆ
ในเวลาเดียวกัน เวบเพจที่เขียนด้วยเจเอสพีทำงานเป็นมัลติเทรดโดยอัตโนมัติ (เวบ
โปรแกรมเมอร์ไม่ต้องสร้างเทรดเอง) อีกทั้งเวลาเวบเซิร์ฟเวอร์โหลดคำสั่งเจเอสพีเข้าไปใน
หน่วยความจำเพื่อทำงาน คำสั่งเจเอสพีจะยังคงค้างอยู่ในหน่วยความจำ เมื่อผู้เยี่ยมชมราย
อื่นเรียกเวบเพจหน้านั้นซ้ำอีกจึงไม่เสียเวลาในการโหลดคำสั่งซ้ำอีก เวบเพจที่ใช้คำสั่ง
เจเอสพีจึงมีความเร็วในการทำงานเป็นอย่างมาก
ประการสุดท้าย เจเอสพี พัฒนาง่าย เพราะสามารถเขียนอยู่ปะปนกับคำสั่ง HTML ในไฟล์
เดียวกัน การพัฒนาเวบไซต์จึงมีความสะดวก รวดเร็ว เข้าใจง่าย