Javacentrix com chap06-0

บทที่ 6 Handling Request & Response Information
สำหรับเนื้อหาภายในบทนี้จะอธิบายถึงว่าจะทำอย่างไร
หากต้องการให้เซิร์ฟเล็ตสามารถอ่านข้อมูลการร้องขอจากโพรโตคอล HTTP
โดยข้อมูลการร้องขอเกิดจากการที่บราวเซอร์ร้องขอข้อมูลมาจากการใช้งานของผู้
ใช้ ซึ่งบราวเซอร์จะส่งทั้งคำสั่ง
และข้อมูลที่บอกลักษณะเฉพาะของบราวเซอร์มาให้เว็บเซิร์ฟเวอร์ทราบว่า
ควรจะจัดส่งข้อมูลอย่างไรจึงจำทำให้สามารถแสดงผลลัพธ์ต่อผู้ใช้ได้อย่างถูกต้อง
ที่สุด
และเนื่องจากเซิร์ฟเล็ตจะต้องรอบรับการใช้งานจากผู้ใช้ที่หลากหลายรูปแบบและ
มีจำนวนมาก
การส่งข้อมูลแบบเดียวกันให้กับผู้ใช้ทั้งหมดเป็นสิ่งที่ไม่ยืดหยุ่นและเหมาะสมเท่า
ที่ควร
ดังในการสร้างระบบที่ดีควรจะสร้างเซิร์ฟเล็ตที่ส่งข้อมูลที่เหมาะสมกับผู้ใช้จึงจะ
ดีที่สุด

จากที่เคยกล่าวไว้แล้วว่าการส่งข้อมูลร้องขอจากบราวเซอร์ไปสู่เว็บเซิร์ฟเวอร์
เกิดจากบราวเซอร์สร้างคำสั่งร้องขอ(โดยการสั่งงานของผู้ใช้)ขึ้นมาเอง แล้วทำการจัดส่งข้อมูลทั้งหมดไปยังเว็บเซิร์ฟเวอร์
คำสั่งร้องขอดังกล่าวนอกจากจะรูปไปในรูปแบบคำสั่ง (POST หรือ GET) ข้อมูลพารามิเตอร์
แล้วยังมีข้อมูลรูปแบบอื่นๆประกอบไปด้วย ซึ่งเรียกว่าข้อมูลร้องขอส่วนหัว (HTTP Response Header)
เมื่อเว็บเซิร์ฟเวอร์ได้รับคำสั่งร้องขอแล้วก็จะทำการพิจารณาว่าจะสามารถดำเนินการตามการร้องขอนั้นได้หรือไม่
หากไม่สามารถดำเนินการได้ก็จะตอบกลับบอกบราวเซอร์ถึงสาเหตุของความไม่สะดวกในการดำเนินการ
และหากคำสั่งร้องขอดังกล่าวเว็บเซิร์ฟเวอร์พิจารณาแล้วเห็นว่าสามารถดำเนินการได้
เว็บเซิร์ฟเวอร์อาจจะอ่านข้อมูลประกอบอื่นๆช่วยในการทำงาน เช่นข้อมูลร้องขอ
เพื่อดูว่าบราวเซอร์มีคุณสมบัติหรือมีความพร้อมในการรับข้อมูลแบบใดได้บ้าง
ก่อนที่จะผลิตหรือสร้างเอกสารให้เหมาะสมกับบราวเซอร์แต่ละตัวและส่งกลับคืนไปให้ใช้ในการแสดงผลลัพธ์ต่อไป
สำหรับในบทนี้เราจะมาเรียนรู้ว่าจะสามารถอ่านข้อมูลร้องขอส่วนหัวจากบราวเซอร์ได้อย่างไร
หลังจากบทที่แล้วได้เรียนรู้เรื่องของการอ่านรูปแบบร้องขอ และข้อมูลพารามิเตอร์จากบราวเซอร์มาแล้ว
ซึ่งแน่นอนว่าจะได้รายละเอียดของข้อมูลที่เพิ่มขึ้นจากเดิม
1. ทำความรู้จักกับ URL และ URI
URL (Uniform Resource Locator) คือเส้นทางในการอ้างถึงแหล่งข้อมูลบนอินเตอร์เน็ต
ซึ่งเป็นที่ทราบแล้วว่าข้อมูลหรือเอกสารที่วางไว้บนอินเตอร์เน็ต
มีมากมายหลายตำแหน่งและยังมีหลากหลายรูปแบบในการที่จะดึงข้อมูลมาใช้งาน ดังนั้น URL
จึงเป็นข้อกำหนดที่สามารถเข้าถึงเอกสารที่ต้องการได้ ซึ่งโดยส่วนใหญ่เราจะเห็นการใช้งาน URL นี้ในการใช้งานเว็บ
แต่ในความเป็นจริงแล้วยังรวมถึงระบบอื่นบนอินเตอร์เน็ตด้วยเช่นระบบ news ระบบ gopher (news และ gopher
ไม่มีให้เห็นและใช้งานกันบ่อยในปัจจุบัน) ระบบ ftp เป็นต้น โดยมีรูปแบบและข้อกำหนดดังนี้
รูปแบบ
Protocol_Name://Host_Name:Port_Number/Document_Path/Document_File
เมื่อ
Protocol_Name คือชื่อโพรโตคอลที่อ้างไปยังปลายทางเช่น HTTP, FTP, NEWS, GOPHER เป็นต้น
Host_Name คือชื่อเครื่องปลายทางที่เก็บเอกสารไว้ ซึ่งสามารถอ้างด้วยทั้งชื่อหรือหมายเลข IP
Port_Number คือหมายเลขพอร์ตสื่อสาร ไม่จำเป็นต้องระบุหากเป็นการสื่อสารด้วยพอร์ตมาตรฐาน
หากระบุต้องตามหลังสัญลักษณ์ :
Document_Path คือเส้นทางเชื่อมโยงไปหาเอกสารเป้าหมาย เช่นเดียวกับอ้างถึงไดเร็กทรอรี่ ซึ่งสามารถระบุได้หลายชั้น
แต่ละชั้นแยกด้วยสัญลักษณ์ / ในบางครั้งชื่อเส้นทางก็เป็นชื่อไดเร็กทรอรี่จริงในระบบ
แต่ในบางครั้งชื่อเส้นทางก็อาจเป็นชื่อเสมือนที่ตั้งขึ้นมาจากผู้บริหารเว็บเซิร์ฟเวอร์
Document_File คือไฟล์เอกสารเป้าหมาย ซึ่งสามารถกำหนดชื่อเอกสารเป้าหมายเป็น ชื่อโปรแกรมเซิร์ฟเล็ต หรือ JSP ก็ได้
ชื่อไฟล์เอกสารนี้ในบางครั้งสามารถระบบข้อมูลพารามิเตอร์ร่วมกับการอ้างชื่อเอกสารด้วย เพื่อให้
เอกสารสามารถรับข้อมูลพารามิเตอร์ไปดำเนินการได้ เช่นเอกสาจากเซิร์ฟเล็ต หรือเอกสาร JSP เป็นต้น
ตัวอย่าง

http://localhost:8080/EJP/servlet/HelloWorld
หมายถึงการอ้างถึงเอกสารในระบบเว็บ (สังเกตจากชื่อโพรโตคอล http) ที่เครื่องเป้าหมายคือเครื่องตนเอง
(localhost หมายถึงเครื่องที่กำลังใช้งาน) ผ่านพอร์ตหมายเลข 8080 ไปยังเซิร์ฟเล็ตที่ชื่อ HelloWorld
ที่อยู่ในเส้นทาง /EJP/servlet
ftp://www.yahoo.com
หมายถึงการอ้างถึงเอกสารในระบบ FTP (สังเกตจากชื่อโพรโตคอล) ผ่านพอร์ตหมายเลขมาตรฐานของ FTP
ซึ่งหากไม่ระบบเส้นทางและเอกสาร จะได้รับเอกสารที่ผู้บริหารกำหนดให้เป็นแบบปริยาย (Default) มาให้
http://www.google.com/search?word=java+programming
หมายถึงการอ้างถึงระบบเว็บ ผ่านพอร์ตหมายเลขมาตรฐานไปยังเครื่องปลายทางชื่อ
www.google.com ผ่านโปรแกรม search โดยมีข้อมูลพารามิเตอร์ประกอบการอ้างถึงไฟล์เว็บใดๆ
(กำหนดเว็บใดๆจากค่าปริยายที่เว็บเซิร์ฟเวอร์)
URI (Uniform Resource Identifier) คือข้อมูลส่วนหนึ่งของ URL
ซึ่งเป็นกลุ่มข้อมูลที่อยู่ต่อท้ายจากชื่อเครื่องปลายทางและหมายเลขพอร์ต (หากระบุ)
เพื่อใช้สำหรับเป็นข้อมูลดำเนินงานในส่วนโปรแกรมที่อยู่บนเว็บเซิร์ฟเวอร์ ตัวอย่างข้อมูล URI
ก็คือเส้นทางและชื่อเอกสารซึ่งหมายรวมถึงพารามิเตอร์ด้วย เช่น
ตัวอย่าง
เมื่อ URL คือ http://localhost:8080/servlet/HelloWorld
ดังนั้น URI คือ /servlet/HelloWorld
เมื่อ URL คือ http://www.google.com/search?word=java+programming
ดังนั้น URI คือ /search?word=java+programming
2. ลักษณะข้อมูลคำสั่งร้องขอส่วนหัว (HTTP Request Header)
จากที่เคยทราบแล้วในเนื้อหาส่วนต้นว่าการสื่อสารของระบบเว็บจะทำให้ทั้งบราวเซอร์และเว็บเซิร์ฟเวอร์มีการสื่อสารกันผ่าน
โพรโตคอล HTTP และแน่นอนว่าการร้องขอข้อมูลของบราวเซอร์ไปยังเว็บเซิร์ฟเวอร์ นอกเหนือจากคำสั่งร้องขอ GET หรือ POST
แล้วบราวเซอร์ยังส่งข้อมูลอื่นๆไปให้เว็บเซิร์ฟเวอร์ด้วย
ข้อมูลที่ว่านี้เป็นส่วนช่วยทำให้เว็บเซิร์ฟเวอร์รู้จักกับลักษณะบราวเซอร์ของผู้ร้องขอเป็นอย่างดี เรียกข้อมูลนี้ว่าข้อมูลร้องขอส่วนหัว
(HTTP Request Header) เช่นเดียวกันในการโต้ตอบคำสั่งร้องขอ เซิร์ฟเวอร์ก็จะส่งข้อมูลสถานะโต้ตอบ ข้อมูลโต้ตอบส่วนหัว
และเนื้อข้อมูลกลับไปด้วย
ต่อไปนี้เป็นภาพแสดงรูปแบบการโต้ตอบระหว่างบราวเซอร์และเว็บเซิร์ฟเวอร์สำหรับการทำงานของคำสั่งในโพรโตคอล HTTP
ภาพแสดงขั้นตอนการร้องขอและโต้ตอบระหว่างบราวเซอร์และเว็บเซิร์ฟเวอร์
ข้อมูลร้องขอจากบราวเซอร์ที่ส่งออกมาให้เว็บเซิร์ฟเวอร์
เมื่อเว็บเซิร์ฟเวอร์ได้รับคำสั่งร้องขอแล้วจะส่งผ่านข้อมูลไปยังเซิร์ฟเล็ต
ซึ่งสามารถตรวจจับข้อมูลดังกล่าวได้จากการเรียกใช้เมธอดที่เกี่ยวข้องในส่วนของคลาส HttpServletRequest
นอกจากนั้นแล้วเซิร์ฟเล็ตยังสามารถจัดการกับสถานะโต้ตอบ, ข้อมูลโต้ตอบส่วนหัว และเนื้อข้อมูลว่าควรจะเป็นอย่างไร
นั้นหมายถึงเซิร์ฟเล็ตสามารถจัดการกับข้อมูลทุกๆส่วนจากการสื่อสารระหว่างบราวเซอร์และเว็บเซิร์ฟเวอร์ได้นั่นเอง

หากผู้อ่านต้องการทราบรายละเอียดเกี่ยวกับโพรโตคอลให้ดูรายละเอียดฉบับสมบูรณ์ได้จากเอกสาร RFC 2616 ที่เว็บไซต์
http://www.rfc-editor.org/
ต่อไปนี้เป็นรายชื่อข้อมูลโต้ตอบส่วนหัวในบางส่วนที่มีการใช้งานกันเป็นส่วนใหญ่
รายละเอียดชื่อฟิลด์ข้อมูลร้องขอส่วนหัว
Accept
บรรจุข้อมูลรายละเอียดรูปแบบ MIME ที่บราวเซอร์รองรับได้ เช่น text/html, image/gif, audio/au เป็นต้น
Accept-Encoding
บรรจุข้อมูลบอกรายละเอียดการบีบอัดข้อมูลทีรอบรับ หากเว็บเซิร์ฟเวอร์ส่งมา เช่น gzip หรือ compress
เพื่อทำให้การรับส่งรวดเร็วยิ่งขึ้น และทางบราวเซอร์จะขยายข้อมูลด้วยความสามารถของบราวเซอร์เอง
Authorization
บรรจุข้อมูลรายละเอียดสิทธิในการใช้งาน ซึ่งประกอบด้วยชื่อผู้ใช้ และรหัสผ่านส่งไปให้เว็บเซิร์ฟเวอร์
Connection
บรรจุข้อมูลรูปแบบการติดต่อ หากเป็น keep-alive หมายถึงช่องทางการติดต่อดังกล่าวจะยังคงเปิดอยู่จนกว่า
ข้อมูลที่ส่งมาจากเว็บเซิร์ฟเวอร์จะสิ้นสุดลง ด้วยการอ่านข้อมูลโต้ตอบส่วนหัวที่ชื่อ Content-Length
Cookie
บรรจุข้อมูลคุกกี้หากเว็บเซิร์ฟเวอร์เคยส่งข้อมูลมาเก็บไว้ที่เว็บเซิร์ฟเวอร์แล้วก่อนหน้านี้
เพื่อกำหนดการเริ่มต้นของการใช้งานหากเป็นการเข้ามายังเว็บเซิร์ฟเวอร์เดิม
Host
บรรจุข้อมูล URL ที่บราวเซอร์เรียกขอข้อมูล
If-Modified-Science
บรรจุข้อมูลวันที่เพื่อบอกให้เว็บเซิร์ฟเวอร์ทราบว่า หากเนื้อข้อมูลที่ร้องขอไม่มีการเปลี่ยนแปลงหลังจากวันดังกล่าว
ก็ไม่จำเป็นต้องเนื้อข้อมูลกลับมา เนื่องจากบราวเซอร์เก็บเนื้อข้อมูลไว้แล้วในครั้งก่อนหน้านี้
Referrer
บรรจุข้อมูล URL ที่อ้างถึงเส้นทางเดียวกันนี้ เพื่อให้บราวเซอร์สามารถอ้างไปยังเนื้อข้อมูลอีกทางหนึ่ง
User-Agent
บรรจุข้อมูลรายละเอียดตัวบราวเซอร์ เช่น ชื่อบราวเซอร์ รุ่น เป็นต้น
3. การอ่านข้อมูลร้องขอส่วนหัว
จากคลาส HttpServletRequest ซึ่งเป็นอินสแตนซ์ที่ได้รับจากอาร์กิวเม็นต์ผ่านเมธอด doPost หรือเมธอด doGet
อินสแตซ์ดังกล่าวสามารถนำมาใช้งานเพื่อเรียกเมธอดที่เกี่ยวข้องกับการอ่านข้อมูลร้องขอส่วนหัวของคลาส HttpServletRequest ได้
ต่อไปนี้เป็นรายชื่อเมธอดที่เกี่ยวข้องที่ใช้ในการเรียกดูข้อมูลส่วนหัวในคำสั่งร้องขอที่ได้รับจากบราวเซอร์
รายชื่อเมธอดที่เกี่ยวข้องกับอ่านข้อมูลโต้ตอบส่วนหัว
รายชื่อเมธอดเฉพาะ
public String getMethod()
สำหรับอ่านข้อมูลคำสั่งร้องขอ ซึ่งจะได้รับผลลัพธ์เช่น GET, POST เป็นต้น

public String getRequestURI()
สำหรับอ่านข้อมูลในส่วน URI จากการอ้างของบราวเซอร์
public String getProtocol()
สำหรับอ่านข้อมูลรายชื่อโพรโตคอลพร้อมเวอร์ชัน เช่น HTTP/1.0 หรือ HTTP/1.1 เป็นต้น
public String getAuthType()
สำหรับอ่านข้อมูลรูปแบบความปลอดภัย เช่น BASIC, DIGEST, SSL หรือ null เป็นต้น
public String getRemoteUser()
สำหรับอ่านข้อมูลชื่อผู้ใช้เพื่อประกอบการสร้างระบบรักษาความปลอดภัย
public int getContentLength()
สำหรับอ่านข้อมูลขนาดความยาวส่วนหัวในส่วน CONTENT-LENGTH ซึ่งจะได้ขนาดเป็นตัวเลขขนาด int
public String getContentType()
สำหรับอ่านข้อมูลส่วนหัวในส่วน CONTENT-TYPE
public Cookie[] getCookies()
สำหรับอ่านออปเจ็คเก็บข้อมูลคุกกี้ในแบบแถวลำดับที่เก็บไว้ที่ระบบของผู้ใช้ (รายละเอียดอยู่ในบทที่ 7)
รายชื่อเมธอดทั่วไป
public long getDateHeader(String HeaderName)
สำหรับอ่านข้อมูลส่วนหัวโดยระบบชื่อข้อมูลและได้รับผลลัพธ์เป็นข้อมูลวันที่ ใช้สำหรับข้อมูลส่วนหัวที่มีข้อมูลวันที่
public int getIntHeader(String HeaderName)
สำหรับอ่านข้อมูลส่วนหัวโดยระบบชื่อข้อมูลและได้รับผลลัพธ์เป็นข้อมูลตัวเลข ใช้สำหรับข้อมูลส่วนหัวที่มีข้อมูลตัวเลข
public String getHeader(String HeaderName)
สำหรับอ่านข้อมูลส่วนหัวใดๆ โดยระบุชื่อและรับข้อมูลเป็นข้อความ
public Enumeration getHeaderNames()
สำหรับอ่านข้อมูลส่วนหัวทั้งหมดและเก็บชื่อที่ได้ไว้ในรูปแบบ Enumeration
ตัวอย่างซอร์สโค้ดเป็นไฟล์ ShowAllHeader.java
เป็นการสร้างเซิร์ฟเล็ตเพื่ออ่านข้อมูลคำสั่งร้องขอส่วนหัวที่ส่งมาจากบราวเซอร์ของผู้ใช้ ซึ่งมีรายละเอียดของโปรแกรมดังนี้
1 import EJP.ThaiUtilities;
2 import EJP.HTMLUtilities;
3 import java.io.*;
4 import java.util.*;
5 import javax.servlet.*;
6 import javax.servlet.http.*;
7
8 public class ShowAllHeader extends HttpServlet {
9 public void doGet (HttpServletRequest request, HttpServletResponse response)
10 throws ServletException, IOException {
11 response.setContentType("text/html; charset=windows-874");
12 PrintWriter out = response.getWriter();
13 HTMLUtilities.createHTMLStart(out, " (Show HTTP
Request Headers)");
14 out.println(" (HTTP Request): " +
15 request.getMethod() + " ");

16 out.println(" URI: " + request.getRequestURI() + " ");
17 out.println(" : " + request.getProtocol() + " ");
18 out.println(" " +
request.getAuthType() + " ");
19 out.println(" : " + request.getRemoteUser() +
" ");
20 out.println(" : " +
request.getContentLength() + " ");
21 out.println(" : " + request.getContentType() +
" ");
22 out.println("<TABLE>");
23
out.println("<TR><TD> </TD><TD>
</TD></TR>");
24 Enumeration e = request.getHeaderNames();
25 while (e.hasMoreElements()) {
26 String name = (String)e.nextElement();
27 String value = request.getHeader(name);
28 out.println("<TR><TD>" + name + ":</TD><TD> " + value + "</TD></TR>");
29 }
30 out.println("</TABLE>");
31 HTMLUtilities.createHTMLEnd(out);
32 }
33 public void doPost (HttpServletRequest request, HttpServletResponse response)
35 doGet(request, response);
36 }
37 }
จากซอร์สโค้ดมีการใช้งานคลาส HttpServletRequest ที่อ้างจากตัวแปร request โดยมีการเรียกใช้เมธอด getMethod
ในบรรทัดที่ 15 เพื่อดูรูปแบบคำสั่งร้องขอ เมธอด getRequestURL ในบรรทัดที่ 16 เพื่อดูข้อมูลในส่วน URL เมธอด getProtocol
ในบรรทัดที่ 17 เพื่อดูชื่อโพรโตคอลที่เรียกใช้งานจากบราวเซอร์ เมธอด getAuthType ในบรรทัดที่ 18 เพื่อเรียกดูสิทธิการใช้งาน เมธอด
getRemoteUser ในบรรทัดที่ 19 เพื่อเรียกดูข้อมูลผู้ใช้ เมธอด getContentLength ในบรรทัดที่ 20 เพื่อเรียกดูความยาวของข้อมูล
และเมธอด getContentType ในบรรทัดที่ 21 เพื่อดูชนิดเอกสารที่บราวเซอร์สามารถนำไปใช้งานได้
ส่วนในบรรทัดที่ 24 เป็นการอ่านชื่อฟิลดในข้อมูลร้องขอส่วนหัวทั้งหมดด้วยเมธอด getHeaderNames มาเก็บไว้ในตัวแปร e
ที่สร้างจาก Enumeration (เนื่องจากเมธอด getHeaderNames คือค่าเป็น Enumuration) จากนั้นนำมาวนลูปในบบรทัดที 25-29
เพื่ออ่านชื่อฟิลด์ที่ละตัวและนำมาใช้งานในเมธอด getHeader เพื่ออ่านข้อมูลสำหรับชื่อฟิลด์นั้นๆ
และสุดท้ายนำชื่อฟิลด์และข้อมูลในฟิลดที่ได้รับมาแสดงในบรรทัดที่ 28
เมื่อนำเอาเซิร์ฟเล็ต ShowAllHeader ไปติดตั้งบนเว็บเซิร์ฟเวอร์ตามตำแหน่งการทำงานที่ถูกต้อง
และทำการทดสอบด้วยการเรียกใช้งานเซิร์ฟเล็ตดังกล่าว ผลลัพธ์ที่ได้จะปรากฏให้เห็นดังต่อไปนี้

รูปแสดงผลลัพธ์จากการทำงานของเซิร์ฟเล็ต ShowAllHeader
จากรูปผลลัพธ์ในการทำงานของเซิร์ฟเล็ตทำให้เห็นข้อมูลที่ได้รับมาจากบราวเซอร์ซึ่งหากพิจารณาข้อมูลในส่วนล่างที่แสดงชื่
อข้อมูลส่วนหัวและข้อมูล มีชื่อฟิลด์ที่ชื่อ accept-language เป็นค่า th
นั่นหมายถึงบราวเซอร์สามารถแสดงข้อมูลด้วยตัวอักษรภาษาไทยได้ และยังสามารถรับข้อมูลที่บีบอัดเข้ามาด้วยวิธี gzip หรือ deflate
ได้ด้วย
จากฟิลด์ user-agent แสดงชื่อโปรแกรมบราวเซอร์ที่คอมเพทิเบิลกับ Mozilla (ชื่อเรียกโปรแกรม Netscape)
และรูปแบบการติดต่อเป็นแบบ Keep-Alive ที่แสดงในบรรทัดสุดท้าย
4. การควบคุมรหัสสถานะโต้ตอบ
หลังจากที่เว็บเซิร์ฟเวอร์ได้รับข้อมูลร้องขอต่างๆทั้งคำสั่ง ข้อมูลพารามิเตอร์ และข้อมูลร้องขอส่วนหัวแล้ว
เซิร์ฟเล็ตสามารถควบคุมการโต้ตอบ ด้วยการกำหนดรหัสสถานะโต้ตอบกลับไปยังบราวเซอร์
เพื่อให้บราวเซอร์ปฏิบัติกิจกรรมตามรหัสสถานะที่ส่งไปให้
การส่งรหัสสถานะนี้เป็นการควบคุมบราวเซอร์จากเซิร์ฟเล็ตในแบบกระฉับซึ่งการควบคุมด้วยรหัสสถานะโต้ตอบนี้
บราวเซอร์จำเป็นต้องปฏิบัติตามคำสั่งด้วยตัวบราวเซอร์เอง ในโพรโตคอล HTTP
มีการระบุรหัสสถานะของการโต้ตอบข้อมูลส่วนหัวเพื่อใช้ในการสนทนาตอบรับระหว่างเว็บเซิร์ฟเวอร์กับบราวเซอร์
ซึ่งมีรายละเอียดตามเอกสารข้อกำหนดโพรโตคอล HTTP รหัสสถานะของ HTTP ในการใช้งานภาษาจาวาถูกแทนด้วยค่าคงที่
โดยตัวแปรค่าคงที่จัดอยู่ในรูปแบบ SC_xxx ที่บรรจุอยู่ภายในคลาส HttpServletResponse เมื่อ xxx คือชื่อสถานะ
รายการรหัสสถานะโต้ตอบต่างๆที่สามารถนำมาใช้งานซึ่งแทนด้วยชื่อตัวแปรมีดังต่อไปนี้
รายชื่อรหัสสถานะและชื่อตัวแปรที่ใช้สำหรับส่งรหัสสถานะโต้ตอบกลับไปยังบราวเซอร์

รหัส 100 ตัวแปร SC_CONTINUE
ใช้ตอบรับบราวเซอร์เมื่อถูกถามถึงการอนุญาตหรือยินยอม
ว่าสามารถให้บราวเซอร์สามารถส่งไฟล์ข้อมูลมาให้ในคำสั่งต่อไปได้
รหัส 101 ตัวแปร SC_SWITCHING_PROTOCOL
ใช้แจ้งให้บราวเซอร์เปลี่ยนการสื่อสารจากโพรโตคอลหนึ่งไปยังอีกโพรโตคอลหนึ่ง
รหัส 200 ตัวแปร SC_OK
แจ้งถึงสภาวะการทำงานปกติในการสื่อสาร
รหัส 201 ตัวแปร SC_CREATED
แจ้งให้บราวเซอร์ทราบว่ามีการสร้างเอกสารขึ้นมาใหม่
จากข้อมูลที่ร้องขอโดยมีการกำหนดตำแหน่งของเอกสารดังกล่าวไว้ในข้อมูลส่วนหัวในส่วน Location ที่ส่งตามมา
รหัส 202 ตัวแปร SC_ACCEPTED
แจ้งให้บราวเซอร์ ทราบว่าการร้องขอได้รับการตอบรับ แต่การดำเนินการตามคำสั่งร้องขอยังไม่สำเร็จสมบูรณ์
รหัส 203 ตัวแปร SC_NON_AUTHORITATIVE_INFORMATION
เนื้อข้อมูลจะส่งกลับให้บราวเซอร์ปกติ แต่ข้อมูลโต้ตอบในส่วนหัวอาจผิดพลาด
หากบราวเซอร์มีการสำเนาเนื้อข้อมูลไปใช้งาน
รหัส 204 ตัวแปร SC_NO_CONTENT
แจ้งให้บราวเซอร์ทราบว่าไม่มีเนื้อข้อมูลไดๆจากการร้องขอ แต่คำสั่งรอขอเป็นผลสำเร็จ
ซึ่งบราวเซอร์ควรจะแสดงเนื้อข้อมูลจากคำสั่งที่แล้วมาใช้งานแทน ข้อมูลสถานะนี้มีประโยชน์อย่างมาก
หากผู้ใช้พยายามสั่งให้บราวเซอร์ร้องขอเอกสารหน้าเดิม (Reload)
โดยเซิร์ฟเล็ตจะตรวจสอบว่าหากเนื้อเอกสารหน้าเดิมดังกล่าวไม่มีการเปลี่ยนแปลงใดๆก็จะส่งสถานะนี้ออกไป
เพื่อเป็นการช่วยลดเวลาและการใช้รับ-ส่งข้อมูลบนระบบเครือข่าย
รหัส 205 ตัวแปร SC_RESET_CONTENT
แจ้งให้บราวเซอร์ทำการรีเซต (reset) เอกสารที่แสดงอยู่ ซึ่งหากเป็นเอกสารที่บรรจุฟอร์มกรอกข้อมูล
ก็จะหมายถึงการล้างข้อมูลออกจากช่องกรอกข้อมูล
รหัส 206 ตัวแปร SC_PARTIAL_CONTENT
แจ้งให้บราวเซอร์ทราบว่าเนื้อข้อมูลที่ส่งไปเป็นเพียงบางส่วนจากเนื้อข้อมูลทั้งหมด
ซึ่งเกิดจากการที่เว็บเซิร์ฟเวอร์แยกส่งข้อมูลเป็นส่วนๆ แทนการส่งทั้งหมดไปในคราวเดียวกัน
รายละเอียดว่าเป็นส่วนไหนของข้อมูลจะบรรจุอยู่ในข้อมูลโต้ตอบส่วนหัวในส่วน Range
รหัส 300 ตัวแปร SC_MULTIPLE_CHOICES
แจ้งให้บราวเซอร์ทราบว่าเอกสารชุดเดียวกับที่ร้องขอนี้ ยังมีเก็บไว้ในหลายที่ ซึ่งบราวเซอร์สามารถร้องขอได้จากที่อื่นด้วย
และข้อมูลตำแหน่งอื่นๆของที่เก็บเอกสาร จะบรรจุอยู่ในข้อมูลโต้ตอบส่วนหัวในชื่อ Location ที่ส่งตามไปด้วย
รหัส 301 ตัวแปร SC_MOVED_PERMANENTLY
เอกสารที่บราวเซอร์ร้องขอถูกย้ายตำแหน่งเก็บไปยังตำแหน่งอื่นอย่างถาวร
โดยข้อมูลตำแหน่งที่ถูกย้ายไปจะบรรจุอยู่ในข้อมูลโต้ตอบส่วนหัวในชื่อ Location ที่จะส่งตามไปด้วย
รหัส 302 ตัวแปร SC_MOVED_TEMPERARILY
เอกสารที่บราวเซอร์ร้องขอถูกย้ายตำแหน่งเก็บไปยังตำแหน่งอื่นชั่วคราว
โดยข้อมูลตำแหน่งที่ถูกย้ายไปจะบรรจุอยู่ในข้อมูลโต้ตอบส่วนหัวในชื่อ Location ที่จะส่งตามไปด้วย

รหัส 303 ตัวแปร SC_SEE_OTHER
แจ้งให้บราวเซอร์เปลี่ยนคำสั่งการร้องขอ เช่น หากบราวเซอร์ร้องขอมาในแบบ POST ก็ให้เปลี่ยนคำสั่งร้องขอใหม่ให้เป็นแบบ
GET
รหัส 304 ตัวแปร SC_NOT_MODIFIED
แจ้งการตอบรับเมื่อเอกสารไม่มีการเปลี่ยนแปลงเนื้อข้อมูล
เมื่อบราวเซอร์ตรวจสอบเนื้อข้อมูลโดยมีการระบุช่วงเวลาเพื่อถามว่าเกิดการเปลี่ยนแปลงหลังจากช่วงเวลาดังกล่าวหรือไม่
หากเนื้อข้อมูลไม่ได้เกิดการเปลี่ยนแปลงเซิร์ฟเวอร์ ก็จะส่งรหัสสถานะนี้กลับไปให้บราวเซอร์
ทำให้บราวเซอร์ไม่ต้องเสียเวลาดึงเนื้อข้อมูลที่เป็นของเดิมไปใช้งาน
หมายเหตุ บราวเซอร์ระบุช่วงเวลาร้องขอโดยกำหนดข้อมูลช่วงเวลาในข้อมูลร้องขอส่วนหัวในส่วน If-Modified-Science
รหัส 305 ตัวแปร SC_USE_PROXY
แจ้งให้บราวเซอร์ดึงเนื้อข้อมูลจากระบบพรอกซี่ (Proxy) เพื่อให้ได้รับข้อมูลที่รวดเร็วขึ้น
เนื่องจากเอกสารดังกล่าวถูกร้องขอมาจากบราวเซอร์อื่นหรือคำสั่งก่อนหน้านี้แล้ว และเอกสารถูกบันทึกไว้ในระบบพรอกซี่
ซึ่งตำแหน่งของระบบพรอกซี่ถูกบรรจุในข้อมูลร้องขอส่วนหัวในส่วน Location
รหัส 400 ตัวแปร SC_BAD_REQUEST
แจ้งให้บราวเซอร์ทราบว่า คำสั่งร้องขอที่ส่งมาก่อนหน้านี้เกิดผิดพลาดทางไวยากรณ์
รหัส 401 ตัวแปร SC_UNAUTHORIZED
เมื่อบราวเซอร์พยายามร้องขอข้อมูลไปหน้าที่ถูกป้องกันหรือให้อ่านได้เฉพาะบางกลุ่ม
ซึ่งบราวเซอร์ไม่ได้ส่งข้อมูลแสดงตัวตนของผู้อ่านมาในข้อมูลร้องขอส่วนหัวในส่วน Authorization มาด้วย
ซึ่งหมายถึงบราวเซอร์จะยังไม่ได้รับอนุญาตให้เรียกดูเอกสารดังกล่าว
รหัส 403 ตัวแปร SC_FORBIDDEN
แจ้งให้บราวเซอร์ทราบถึงความผิดพลาดหรือการไม่อนุญาต
เมื่อบราวเซอร์พยายามเรียกดูเอกสารที่ไม่มีอยู่หรือเอกสารที่ถูกกำหนดสิทธิในการเรียกดู
รหัส 404 ตัวแปร SC_NOT_FOUND
เป็นสถานะความผิดพลาดที่พบเห็นกันบ่อยที่สุด
ซึ่งหมายถึงการร้องขอจากบราวเซอร์ที่ไม่มีเอกสารดังกล่าวอยู่ที่เว็บเซิร์ฟเวอร์
รหัส 405 ตัวแปร SC_METHOD_NOT_ALLOWED
แจ้งบราวเซอร์เมื่อได้รับคำสั่งร้องขอที่เว็บเซิร์ฟเวอร์ไม่รองรับคำสั่ง
รหัส 407 ตัวแปร SC_PROXY_AUTHENTICATION_REQUESTED
แจ้งบราวเซอร์เมื่อระบบพรอกซึ่งไม่อนุญาตให้มีการอ่านเอกสารฉบับดังกล่าว
รหัส 408 ตัวแปร SC_REQUEST_TIMEOUT
แจ้งบราวเซอร์เมื่อเอกสารที่ร้องขอมีความยาวมาก จนเว็บเซิร์ฟเวอร์ไม่สามารถรอเวลาให้ส่งเอกสารจนจบได้
เนื่องจากต้องย้ายการทำงานไปยังส่วนอื่น หรือหมดเวลาที่ผู้ควบคุมระบบตั้งไว้
รหัส 409 ตัวแปร SC_CONFLICT
ใช้ควบคู่กับคำสั่ง PUT เมื่อบราวเซอร์พยายามพยายามอัพโหลดไฟล์ที่มีข้อแตกต่างในตัวเลขเวอร์ชัน
รหัส 410 ตัวแปร SC_GONE

เว็บเซิร์ฟเวอร์แจ้งให้บราวเซอร์ทราบว่าเอกสารที่ร้องขอ เป็นเอกสารที่ถูกยกเลิกออกจากระบบ
รหัส 411 ตัวแปร SC_LENGTH_REQUIRED
เมื่อบราวเซอร์พยายามอัพโหลดไฟล์ไปยังเว็บเซิร์ฟเวอร์ และเว็บเซิร์ฟเวอร์ต้องการข้อมูลเพิ่มเติมคือความยาวของขนาดไฟล์
รหัส 412 ตัวแปร SC_PRECONDITION_FAILED
แจ้งบราวเซอร์ที่ข้อมูลบางส่วนที่อยู่ในส่วนข้อมูลร้องขอไม่สมบูรณ์หรือไม่ถูกต้อง
รหัส 413 ตัวแปร SC_REQUEST_ENTITY_TOO_LARGE
แจ้งบราวเซอร์เมื่อเว็บเซิร์ฟเวอร์ไม่สามารถรับข้อมูลที่บราวเซอร์ร้องขอมา
เนื่องจากคำสั่งร้องขอจากบราวเซอร์มีขนาดมากเกินที่เว็บเซิร์ฟเวอร์จะตรวจรับได้
รหัส 414 ตัวแปร SC_REQUEST_TOO_LONG
แจ้งบราวเซอร์เมื่อเว็บเซิร์ฟเวอร์ไม่สามารถรับข้อมูลที่บราวเซอร์ร้องขอมา เนื่องจากคำสั่งร้องขอจากบราวเซอร์ในส่วน URI
มีขนาดมากเกินที่เว็บเซิร์ฟเวอร์จะตรวจรับได้
รหัส 415 ตัวแปร SC_UNSUPPORTED_MEDIA_TYPE
เว็บเซิร์ฟเวอร์แจ้งให้บราวเซอร์ทราบ เมื่อบราวเซอร์พยายามส่งไฟล์ในประเภทหรือชนิดที่เว็บเซิร์ฟเวอร์ไม่รู้จัก
และไม่สามารถรับไฟล์ดังกล่าวเข้ามาเก็บไว้ได้
รหัส 500 ตัวแปร SC_INTERNAL_SERVER_ERROR
เป็นสถานะที่แจ้งให้กับบราวเซอร์เมื่อเกิดจากการทำงานผิดพลาดของระบบภายในเว็บเซิร์ฟเวอร์
รหัส 501 ตัวแปร SC_NOT_IMPLEMENTED
แจ้งบราวเซอร์เมื่อเว็บเซิร์ฟเวอร์ไม่มีฟังก์ชันรองรับคำสั่งร้องขอ เช่น ไม่มีฟังก์ชันรอบรับการร้องขอด้วยคำสั่ง GET เป็นต้น
รหัส 502 ตัวแปร SC_BAD_GATEWAY
เมื่อระบบพรอกซี่หรือเกตเวย์ (Gateway) เกิดข้อผิดพลาดขึ้นและไม่สามารถรอบรับการทำงานได้
รหัส 503 ตัวแปร SC_SERVICE_UNAVAILABLE
แจ้งบราวเซอร์ กรณีที่เว็บเซิร์ฟเวอร์ไม่สามารถโต้ตอบกับบราวเซอร์ได้ในช่วงเวลานั้น
รหัส 504 ตัวแปร SC_GATWAY_TIMEOUT
แจ้งบราวเซอร์เมื่อเว็บเซิร์ฟเวอร์ที่ทำงานเป็นพรอกซี่หรือเกตเวย์หมดเวลาโต้ตอบคำสั่งร้องขอตามที่กำหนดไว้โดยผู้ควบคุม
รหัส 505 ตัวแปร SC_HTTP_VERSION_NOT_SUPPORTED
เมื่อเว็บเซิร์ฟเวอร์ไม่รองโพรโตคอล HTTP ตามเวอร์ชันที่บราวเซอร์ส่งมา
จากข้อมูลตัวแปรค่าคงที่ที่มีรายละเอียดที่ส่วนบน สามารถนำมาใช้กับเมธอดของคลาส HttpServletReponse
เพื่อส่งข้อมูลสถานการณ์โต้ตอบกลับไปให้บราวเซอร์ด้วยเมธอดดังนี้
เมธอด setStatus สำหรับส่งรหัสสถานะกลับไปยังบราวเซอร์
รูปแบบ
public void setStatus(int status_code)
เมื่อ

status_code คือค่าตัวแปรคงที่รหัสสถานะตามรายละเอียดด้านบน หรือตัวเลขรหัสอย่างใดอย่างหนึ่ง
ข้อแนะนำ เนื่องจากเมธอด setStatus
ซึ่งใช้บอกสถานการณ์ตอบกลับไปยังบราวเซอร์ซึ่งเป็นข้อมูลที่จะประกฎก่อนข้อมูลโต้ตอบส่วนหัวและข้อมูลเนื้อเอกสาร
ดังนั้นจึงควรวางเมธอด setStatus ไว้ก่อนการส่งข้อมูลใดๆเสมอ
นอกจากนี้แล้วยังมีเมธรดที่ทำงานในสถานะที่มีการเกิดขึ้นบ่อยๆคือสถานะความผิดพลาด (รหัส 404)
หรือกลุ่มสถานะความผิดพลาด (นำหน้าด้วยเลข 4) และสถานการณ์ย้ายเอกสาร (รหัส 302) ดังนี้
เมธอด sendError สำหรับส่งรหัสสถานะพร้อมข้อมูลกลับไปยังบราวเซอร์
รูปแบบ
public void sendError(int error_code, String message)
เมื่อ
error_code คือสถานะข้อผิดพลาด หากเป็นรหัส 404 จะใช้ค่า SC__NOT_FOUND เป็นต้น
message คือข้อความที่จะส่งให้กับบราวเซอร์
เมธอด sendRedirect สำหรับย้ายเส้นทางไปยังตำแหน่ง URL อื่นๆ
รูปแบบ
public void sendRedirect(String url)
คำสั่งรีไดเร็กหรือย้ายตำแหน่งการทำงานซึ่งจะส่งรหัส 302 เป็นค่าสถานะและจะส่งข้อมูล url
ไปในข้อมูลส่วนหัวตอบกลับ
ในส่วน Location ให้บราวเซอร์รับรู้ว่าควรย้ายเส้นทางการเรียกดูไปยังเส้นทางใหม่ดังกล่าว
เมื่อ
url คือข้อมูล URL ปลายทางที่จะบอกให้บราวเซอร์ย้ายตำแหน่งไปยังข้อมูลดังกล่าว
ข้อแนะนำ การรีไดเร็ก (Redirect) ในการทำงานของระบบเว็บสามารถทำได้หลายรูปแบบ
หากเป็นการทำโดยเซิร์ฟเล็ตก็จะทำงานผ่านเมธอด sendRedirect แต่หากทำงานด้วยคำสั่ง HTML ก็สามารถระบุข้อมูลแท็ก META เช่น
<META HTTP-EQUIV="Refresh" …> ได้เช่นกัน
ในการทำงานของเว็บเซิร์ฟเวอร์เมื่อบราวเซอร์ร้องขอไฟล์ที่ไม่มีอยู่ในระบบแล้ว
โดยมากเว็บเซิร์ฟเวอร์จะส่งรหัสสถานการณ์ตอบรับ 404 กลับไปยังบราวเซอร์ เพื่อแจ้งให้ผู้ใช้ทราบว่าไม่มีข้อมูลตามที่ผู้ใช้เรียกดู
และการบริหารเว็บเซิร์ฟเวอร์โดยส่วนใหญ่มักจะให้ผู้บริหารเว็บเซิร์ฟเวอร์ได้ควบคุมข้อมูลการแสดงผลที่มากกว่าการส่งรหัสแต่เพียงอย่
างเดียว เช่น การแสดงข้อมูลที่อธิบายรายละเอียดของปัญหาและแจ้งขอโทษต่อความรับผิดชอบในความบกพร่องนี้
หรืออาจจะแสดงรูปภาพที่บอกข้อมูลให้ผู้ใช้ทราบถึงข้อบกพร่องในการทำงาน เป็นต้น
ซอร์สโค้ดต่อไปจะอธิบายถึงเซิร์ฟเล็ต SetResponseStatus1 ในไฟล์ SetResponseStatus1.java
ที่จะทำหน้าที่ในการส่งรหัสสถานะไปยังบราวเซอร์ โดยให้ทำงานผ่านทางเมธอด setStatus และกำหนดรหัสสถานะ 403
หรือด้วยการใช้ค่าคงที่จากตัวแปร SC_FORBIDDEN ที่บรรจุอยู่ภายในคลาส HttpServletResponse อย่างใดอย่างหนึ่งดังนี้
3

4 public class SetResponseStatus1 extends HttpServlet {
6 throws ServletException {
7 response.setStatus(HttpServletResponse.SC_FORBIDDEN);
8 }
10 throws ServletException{
12 }
13 }
ซึ่งก่อนที่จะใช้งานเซิร์ฟเล็ต SetResponseStatus1 หากเป็นการทดสอบจากบราวเซอร์ที่ชื่อ Internet Explorer
จำเป็นต้องกำหนดค่าการแสดงผลลัพธ์บางอย่างก่อน เนื่องจากบราวเซอร์ดังกล่าว
มีความสามารถจัดการแสดงผลแจ้งให้ผู้ใช้ทราบหากได้รับรหัสสถานะจากเว็บเซิร์ฟเวอร์ ด้วยรูปแบบเฉพาะของบราวเซอร์เอง
ซึ่งทำให้ในบางครั้งไม่สามารถสังเกตได้ว่ารหัสสถานะที่ได้รับจริงๆจากเว็บเซิร์ฟเวอร์เป็นเช่นได
การปิดความสามารถนี้ทำได้โดยให้เลือกที่เมนู Tools -> Internet Options… จากนั้นเมื่อปรากฏไดอะล็อกบล็อกดังรูป
ให้มองหาแท็บที่ชื่อ Advanced และให้เลือกแท็ปดังกล่าวจากนั้นสังเหตหาหัวข้อ Show friendly HTTP error messages
ให้คลิกเพื่อยกเลิกคือการนำเครื่องหมายถูกออกจากช่องเลือกรายการดังกล่าว เพื่อยกเลิกลักษณะการทำงานตามที่ได้อธิบายไว้
รูปแสดงการยกเลิกออปชั่นในการบังคับการแสดงผลข้อผิดพลาดใน Internet Explorer
เมื่อเรียกใช้งานเซิร์ฟเล็ต SetResponseStatus1 ผู้ใช้จะสังเกตเห็นรหัสสถานะ 403
แสดงที่จะพื้นที่แสดงผลของบราวเซอร์เนื่องจากเซิร์ฟเล็ตส่งรหัสผ่านเว็บเซิร์ฟเวอร์มา
(จากตัวอย่างเป็นการทดสอบเซิร์ฟเล็ตบนเว็บเซิร์ฟเวอร์ Apache Tomcat 4.0.1)

รูปแสดงข้อผิดพลาดที่ได้รับจากเว็บเซิร์ฟเวอร์เมื่อเรียกใช้ SetResponseStatus1
ซึ่งส่งรหัสสถานะตอบกลับไม่อนุญาตให้ใช้งาน (Forbidden)
ลองพิจารณาตัวอย่างของไฟล์ SetResponseStatus2.java
ด้านล่างซึ่งเป็นตัวอย่างซอร์สโค้ดที่ทำงานโดยการส่งรหัสสถานะตอบกลับด้วยการทำงานผ่านเมธอด sendError
1 import java.io.*;
2 import java.util.*;
5
6 public class SetResponseStatus2 extends HttpServlet {
9 response.setContentType("text/html; charset=windows-874");
10 response.sendError(HttpServletResponse.SC_NOT_FOUND,
11 " SetResponseStatus2");
12 }
16 }
17 }
สำหรับเซิร์ฟเล็ต SetResponseStatus2 เป็นการสร้างเซิร์ฟเล็ตให้มีการส่งข้อผิดพลาดรหัส 404 ด้วยเมธอด sendError
ที่ปรากฏอยู่ในบรรทัดที่ 10 ซึ่งเป็นการส่งข้อความ “ไม่พบข้อมูลที่ต้องการทำงานจาก SetResponse2” ไปร่วมกับคำสั่งดังกล่าวด้วย
เพื่อใช้ในการชี้แจ้งข้อผิดพลาดดังกล่าว ส่วนใหญ่แล้วรหัสสถานะตอบกลับ 404
ถูกใช้กรณีที่ไม่พบไฟล์เอกสารที่บราวเซอร์อ้างอิงมาจากตำแหน่ง URL
รูปแสดงผลลัพธ์จากการทำงานของเซิร์ฟเล็ต SetResponseStatus2
ตัวอย่างซอร์สโค้ดในไฟล์ SetResponseRedirect.java เป็นการทำงานเพื่อย้ายการทำงานไปยังตำแหน่งใหม่
1 import java.io.*;

4
5 public class SetResponseRedirect extends HttpServlet {
8 response.sendRedirect("http://www.javacentrix.com");
9 }
13 }
14 }
เซิร์ฟเล็ต SetResponseRedirect ทำหน้าที่โยกย้ายการทำงานไปยังตำแหน่งใหม่ ด้วยการเรียกใช้เมธอด sendRedirect
ในบรรทัดที่ 8 ซึ่งจะทำการส่งรหัสสถานะ 302 ตอบกลับไปยังบราวเซอร์
โดยเมธอดดังกล่าวต้องมีการระบุของมูลปลายทางตำแหน่งใหม่ในอาร์กิวเม็นต์
เพื่อให้บราวเซอร์โยกย้ายเส้นทางการอ่านข้อมูลไปยังเส้นทางดังกล่าว จากตัวอย่างคือย้ายไปยังเว็บไซต์ http://www.javacentrix.com
นั่นเอง
5. รายละเอียดข้อมูลโต้ตอบส่วนหัว
โพรโตคอล HTTP ที่ถูกใช้ในการโต้ตอบจากการร้องขอของบราวเซอร์นั้นนอกจากจะมีรหัสสถานะตอบกลับแล้ว
ยังประกอบไปด้วยข้อมูลโต้ตอบส่วนหัว (HTTP Response Header) ซึ่งข้อมูลดังกล่าวคล้ายกับข้อมูลร้องขอส่วนหัว (HTTP Request
Status) ที่เคยกล่าวมาแล้วในหัวข้อก่อนหน้านี้ แต่ข้อมูลการโต้ตอบส่วนหัวที่ส่งไปจากเว็บเซิร์ฟเวอร์นั้น
เป็นการส่งข้อมูลล่วงหน้าเพื่อบอกให้บราวเซอร์เตรียมความพร้อมก่อนที่จะส่งเนื้อข้อมูลเอกสารกลับไปให้ ยกตัวอย่างเช่น
หากเว็บเซิร์ฟเวอร์ต้องการส่งรูปภาพไปให้บราวเซอร์ ก็จะส่งข้อมูลตอบกลับส่วนหัวบอกไปก่อนว่า
เนื้อข้อมูลที่ส่งต่อจากนี้เป็นรูปภาพในฟอร์แมตหนึ่ง หรือหากเนื้อข้อมูลที่จะส่งไปเป็นเอกสารที่บรรจุด้วยตัวอักษรภาษาญี่ปุ่น
ก็จะส่งชื่อรหัสตัวอักษรกลับไปยังบราวเซอร์เพื่อบอกถึงเนื้อข้อมูลในภาษาญี่ปุ่น เป็นต้น
ต่อไปนี้เป็นรายชื่อข้อมูลโต้ตอบส่วนหัวในบางส่วนที่มีการใช้งานกันเป็นส่วนใหญ่
รายละเอียดชื่อฟิลด์ข้อมูลโต้ตอบส่วนหัว
Allow
กำหนดลักษณะคำสั่งร้องขอที่ยอมรับการร้องจากบราวเซอร์ เช่น GET, POST หากคำสั่งร้องขอที่ส่งมา
จากบราวเซอร์ไม่ใช้ตามที่ต้องการ เว็บเซิร์ฟเวอร์จะส่งข้อมูลรหัสสถานะ 405 กลับไป
Cache-Control
บอกการควบคุมให้กับบราวเซอร์ว่าควรจะดำเนินการอย่างไรในการจัดเก็บ เมื่อเนื้อข้อมูลส่งมาถึงบราวเซอร์
ตามรายละเอียดดังนี้
public หมายถึงเนื้อข้อมูลสามารถจัดเก็บไว้ในพื้นที่แคชได้ เพื่อรองรับผู้ใช้รายอื่นๆ
private หมายถึงเนื้อข้อมูลไม่สามารถจัดเก็บได้ เนื่องจากใช้สำหรับผู้ใช้ในขณะนี้เท่านั้น
no-cache หมายถึงไม่อนุญาตให้ทำการจัดเก็บเนื้อข้อมูลไว้
no-store หมายถึงไม่อนุญาตให้จัดเก็บเนื้อข้อมูลไว้ ทั้งในแคช หรือที่จัดเก็บชั่วคราวใดๆทั้งสิ้น
must-revalidate หมายถึงบราวเซอร์ต้องตรวจสอบเนื้อข้อมูลจากเว็บเซิร์ฟเวอร์ที่เป็นเจ้าของทุกครั้ง
proxy-revalidate หมายถึงบราวเซอร์สามารถตรวจสอบเนื้อข้อมูลจากแคชในทุกครั้ง

max-age=xxx หมายถึงเนื้อข้อมูลควรถูกจัดเก็บไว้ในเวลาเท่าไรตามจำนวน xxx
s-max-age=xxx หมายถึงเนื้อข้อมูลควรถูกจัดเก็บไว้ในแคชในเวลาเท่าไรตามจำนวน xxx
Content-Encoding
บอกให้บราวเซอร์ทราบว่าเนื้อข้อมูลที่จะส่งตามมา ถูกบีบอัดมาในรูปแบบใด
เพื่อที่บราวเซอร์จะได้ขยายข้อมูลก่อนนำไปใช้งาน
Content-Length
บอกความยาวของเนื้อข้อมูลให้กับบราวเซอร์
Content-Type
บอกรูปแบบเนื้อข้อมูลที่จะส่งตามมาว่าเป็นอะไร เช่น เนื้อเอกสาร เสียง หรือรูปภาพ เป็นต้น
Expires
บอกให้บราวเซอร์ทราบว่าเนื้อข้อมูลที่จะส่งไปนี้สามารถใช้ได้จนถึงเมื่อใด
และหลังจากนั้นถือว่าเนื้อข้อมูลไม่ใช้ที่เป็นปัจจุบัน
Last-Modified
บอกให้ทราบถึงวันที่ปรับปรุงครั้งล่าสุดของเนื้อข้อมูล
Refresh
กำหนดให้บราวเซอร์มีการดึงข้อมูลอีกครั้งในช่วงเวลา และเส้นทางที่กำหนด
Set-Cookie
กำหนดข้อมูลคุกกี้ที่ส่งให้กับบราวเซอร์ทำการจัดเก็บไว้ หากบราวเซอร์ยินยอมในการทำงานของคุกกี้
WWW-Authenticate
บอกรายละเอียดของสิทธิในการใช้งานเนื้อข้อมูล
6. การควบคุมข้อมูลโต้ตอบส่วนหัว
สำหรับการควบคุมข้อมูลโต้ตอบส่วนหัวด้วยเซิร์ฟเล็ตนั้น ต้องทำงานผ่านเมธอดต่างๆที่อยู่ในคลาส HttpServletResponse
โดยการใช้งานให้วางเมธอดไว้ที่บริเวณสเตจเม็นแรกๆของการสร้างเซิร์ฟเล็ต
รายชื่อเมธรอดที่ใช้ส่งข้อมูลโต้ตอบส่วนหัว
รายชื่อเมธอดเฉพาะ
void setContentType(String header)
กำหนดลักษณะของเนื้อข้อมูลที่จะส่งไปให้บราวเซอร์ว่าอยู่ในรูปแบบใด เมื่อ header คือรายละเอียดเนื้อข้อมูล
void setContentLength(int length)
กำหนดความยาวของข้อมูลว่ามีความยาวเท่าไร เพื่อคำนวณระยะเวลาที่บราวเซอร์จะเปิดช่องทางการสื่อสารไว้
เมื่อ length คือความยาวเนื้อข้อมูลที่ต้องการส่งไปให้บราวเซอร์
void sendRedirect(String url)
เมธอดนี้มีรายละเอียดในหัวข้อที่ผ่านมา ซึ่งมีผลถึงข้อมูลถึงสถานะโต้ตอบ ถูกใช้ในการย้ายตำแหน่งเอกสาร
รายชื่อเมธอดทั่วไป
setHeader (String header_name, string string_value)

setDateHeader (String header_name, long milliseconds)
setIntHeader (String header_name, int int_value)
เมื่อ
header_name คือชื่อส่วนหัวในการโต้ตอบ
string_value คือข้อมูลโต้ตอบส่วนหัวที่เป็นลักษณะข้อความ ใช้กับเมธอด setHeader
milliseconds คือข้อมูลโต้ตอบส่วนหัวที่เป็นลักษณะเวลา ใช้กับเมธอด setDateHeader
int_value คือข้อมูลโต้ตอบส่วนหัวที่เป็นลักษณะตัวเลข ใช้กับเมธอด setIntHeader
ตัวอย่างซอร์สโค้ดต่อไปนี้คือคลาส GraphProducer ในไฟล์ GraphProducer.java
ที่ใช้สำหรับการสร้างกราฟเส้นตรงตามข้อมูลที่กำหนดไว้ด้วยการใส่ข้อมูลผ่านเมธอด putValue คลาสนี้มีการคำนวณการลากเส้นแกน
X และ Y การพล็อตจุดในแต่ละค่า รวมถึงการลากเส้นกราฟตามวิธีการวาดกราฟบนจอภาพ เมธอดที่ใช้เริ่มต้นในการวาดกราฟคือ
createGraph ซึ่งจะรับข้อมูลที่จะส่งมา ทางอาร์กิวเม็นต์เพื่อส่งข้อมูลกราฟในรูปแบบ JPEG กลับไป
ให้พิจารณาจากซอร์สโค้ดและคำอธิบายที่อยู่ภายในซอร์สโค้ดสำหรับคลาส GraphProducer
15 import java.io.*;
16 import java.awt.*;
17 import java.awt.image.*;
18
19 import com.sun.image.codec.jpeg.JPEGCodec;
20 import com.sun.image.codec.jpeg.JPEGImageEncoder;
21
22 public class GraphProducer {
23 private Graphics2D graphics;
24 private int ImageWidth = 300; //
25 private int ImageHeight = 500; //
26 private int VertInset = 25; //
27 private int HorzInset = 25; //
28
29 private int VertStart = 0; // Y
30 private int VertEnd = 100; // Y
31 private int VertGap = 10; // Y
32
33 private int HorzStart = 0; // X
34 private int HorzEnd = 10; // X
35
36 private String barInfo[]; // X
37 private int barValue[]; // X
38
39 public void setSize(int x, int y, int x_magin, int y_magin) {
40 //
X Y
41 ImageWidth = x;
42 ImageHeight = y;
43 HorzInset = x_magin;
44 VertInset = y_magin;
45 }
46
47 public void setY(int start, int end, int gap) {
48 //
Y

49 VertStart = start;
50 VertEnd = end;
51 VertGap = gap;
52 }
53
54 public void setX(int start, int end) {
55 // X
56 HorzStart = start;
57 HorzEnd = end;
58 }
59
60 public void putValue(String info[], int values[]) {
61 // X info
values
62 //
63 barInfo = info;
64 barValue = values;
65 }
66
67 public void createGraph(OutputStream stream) throws IOException {
68 //
JPEG
69 JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(stream);
70 //
71 BufferedImage bi = new BufferedImage(ImageWidth + 10,
72 ImageHeight, BufferedImage.TYPE_BYTE_INDEXED);
73
74 //
graphics
75 graphics = bi.createGraphics();
76 graphics.setColor(Color.white); //
77 graphics.fillRect(0, 0, bi.getWidth(), bi.getHeight()); //
78
79 int pointValue[] = createPoint(barValue); // Y
80
81 graphics.setColor(Color.red); // X Y
82 createVerticalAxis(); // Y
83 createHorizontalAxis(barInfo); // X
barInfo
84
85 graphics.setColor(Color.green); //
86 plotPoints(pointValue); //
87
88 graphics.setColor(Color.blue); //
89 plotLine(pointValue); //
90
91 encoder.encode(bi); // JPEG
92 }
93
94 int[] createPoint(int bars[]) {
95 //
X
96 int points[] = new int[bars.length];

97 int verticalLength = ImageHeight - (VertInset * 2);
98 int VertLine = (VertEnd-VertStart)/VertGap;
99 int interval = verticalLength/VertLine;
100
101 for (int i = 0;i < bars.length; i++) {
102 int point = (100*bars[i] / (VertEnd - VertStart)) - VertStart;
103 points[i] = VertInset + verticalLength - (point * verticalLength / (VertEnd - VertStart));
104 }
105 return points;
106 }
107
108 void createVerticalAxis() {
109 int verticalLength = ImageHeight - (VertInset * 2);
110 int VertLine = (VertEnd-VertStart)/VertGap;
111 int interval = verticalLength/VertLine;
112
113 graphics.drawLine(HorzInset, VertInset, HorzInset, ImageHeight - VertInset);
114 for(int i=0; i<=VertLine; i++) {
115 graphics.drawLine(HorzInset - 3, VertInset + (i*interval),
116 HorzInset + 3, VertInset + (i*interval));
117 graphics.drawString((VertStart + ((VertLine - i) * VertGap)) + "",
118 2, VertInset + (i*interval));
119 }
120 }
121
122 void createHorizontalAxis(String []bars) {
123 int HorzLength = ImageWidth - (HorzInset * 2);
124 int HorzLine = bars.length;
125 int interval = HorzLength/HorzLine;
126
127 graphics.drawLine(HorzInset, ImageHeight - VertInset,
128 ImageWidth - HorzInset, ImageHeight - VertInset);
129 for(int i=0; i<HorzLine; i++) {
130 int x = HorzInset + (i*interval) + interval;
131 graphics.drawLine(x, ImageHeight - VertInset - 3, x, ImageHeight - VertInset + 3);
132 graphics.drawString(bars[i], x, ImageHeight - VertInset + 12);
133 }
134 }
135
136 void plotPoints(int[] points) {
138 int HorzLine = points.length;
140
141 for(int i=0; i<HorzLine; i++) {
142 int x = HorzInset + (i*interval) + interval;
143 graphics.draw3DRect(x-2, points[i]-2, 4, 4, true);
144 }
145 }
146
147 void plotLine(int[] points) {
149 int HorzLine = points.length;
151 for(int i=0; i<HorzLine - 1; i++) {
152 int x1 = HorzInset + (i*interval) + interval;

153 int x2 = x1 + interval;
154 graphics.drawLine(x1, points[i], x2, points[i+1]);
155 }
156 }
157 }
จากซอร์สโค้ดด้านบนเมธอดที่ใช้ในการกำหนดพื้นที่ของกราฟคือ setSize ส่วนเมธอด setX และ setY
ถูกใช้สำหรับกำหนดการแสดงค่าในแกน X และ Y ตามลำดับ ในขณะที่ข้อมูลที่จะส่งไปใช้ในการแสดงกราฟคือเมธอด putValue
สุดท้ายเมื่อต้องการให้เริ่มสร้างกราฟจะเรียกใช้งานเมธอด createGraph ลองดูตัวอย่างการใช้งานจากเซิร์ฟเล็ตในไฟล์ GraphServlet
ที่จะสร้างกราฟตามข้อมูลที่กำหนดภายใน ดังนี้
3 import java.io.*;
4
5 public class GraphServlet extends HttpServlet {
6 public void doGet(HttpServletRequest request, HttpServletResponse response)
7 throws IOException, ServletException {
8 response.setContentType("image/jpg");
9 GraphProducer graph = new GraphProducer();
10 String barInfo[] = { "Sun", "Mon", "Tue", "Thu", "Wed", "Fri", "Sat" };
11 int barValue[] = { 67, 50, 53, 80, 75, 95, 86};
12 graph.setSize(400, 200, 30, 30);
13 graph.setX(0, 100);
14 graph.setY(0, 100, 10);
15 graph.putValue(barInfo, barValue);
16 graph.createGraph(response.getOutputStream());
17 }
18 }
จากซอร์สโค้ดด้านบนเป็นการสร้างเซิร์ฟเล็ตเพื่อแสดงกราฟเส้นตรงโดยการใช้คลาส GraphProducer ที่ผ่านมา
เนื่องจากเซิร์ฟเล็ตนี้ให้ผลลัพธ์เป็นภาพกราฟที่อยู่ในฟอร์แมต JPEG ดังนั้นในบรรทัดที่ 8 จึงมีการกำหนด Content Type ด้วยเมธอด
setContentType ด้วยข้อมูล image/jpg ซึ่งใช้กรณีบอกให้บราวเซอร์ทราบว่าข้อมูลที่จะส่งไปเป็นภาพแบบ JPEG สำหรับในบรรทัดที่ 9
เป็นการสร้างอินสแตนซ์สำหรับคลาส GraphProducer ให้กับตัวแปร graph ในบรรทัดที่ 10 - 14
เป็นการกำหนดข้อมูลในการวาดกราฟ จากตัวอย่างให้เป็นยอดขายสิ้นค้าในแต่ละวันในหนึ่งสัปดาห์ สำหรับในบรรทัดที่ 16
เป็นการสั่งให้มีการสร้างรูปกราฟจากข้อมูลดังกล่าว จะเห็นว่ามีการผ่านอาร์กิวเม็นต์ response.getOutputStream()
ซึ่งเป็นการส่งเอาอินสแตนซ์ที่ใช้จัดการส่งข้อมูลกลับในแบบสตรีม (ส่งทีละไบต์) เข้าไปใช้งานในเมธอด createGraph
รูปแสดงภาพกราฟที่ได้จากเซิร์ฟเล็ต GraphServlet

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

Javacentrix com chap06-0

More Related Content

Similar to Javacentrix com chap06-0 (20)

More from Theeravaj Tum (20)

Javacentrix com chap06-0