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

2. 1. ความหมายของจาวาบีนสำหรับ JSP
หากผู้อ่านได้เคยทำความรู้จักกับจาวาบีน (JavaBean) มาก่อนหน้านี้แล้ว
หรือเคยใช้งานแอปพลิเคชั่นที่เกี่ยวกับการพัฒนาโปรแกรมในลักษณะวีชวล (Visual Programming) เช่นโปรแกรม Forte for Java,
JBuilder, JRun Studio
แอปพลิเคชั่นเหล่านี้ล้วนแล้วอาศัยคุณสมบัติในการทำงานของจาวาบีนในการนำมาสร้างเป็นโปรแกรมที่ได้จากภาษาจาวา
ยกตัวอย่างเช่นหากต้องการสร้างโปรแกรมที่มีพื้นที่บรรจุด้วยช่องกรอกข้อความและปุ่ม
ก็เพียงแต่ใช้แอปพลิเคชั่นใดแอปพลิเคชั่นหนึ่งสร้างขึ้นมาด้วยวิธีการลากช่องกรอกข้อความ
และปุ่มจากตัวเลือกที่มีให้เลือกแล้ววางไปบนฟอร์มเปล่า ตัวเลือกที่แอปพลิเคชั่นเหล่านั้นคือจาวาบีนซึ่งเป็นคนละประเภท เช่น
จาวาบีนช่องกรอกข้อความ จาวาบีนปุ่ม
การวางจาวาบีนแต่ละตัวลงบนพื้นที่ฟอร์มจะเกิดภาษาจาวาขึ้นมาโดยอัตโนมัติที่มีคำสั่งในการเขียนเพื่อเลือกเอาจาวาบีนแต่ละตัวมาใช้งา
น
รูปแสดงการใช้งานจาวาบีนจากแอปพลิเคชั่นพัฒนาโปรแกรมจำพวกวีชวล
หลักการทำงานของจาวาบีนที่เกิดขึ้นจากแอปพลิเคชั่นพัฒนาโปรแกรมแบบวีชวล
แท้ที่จริงคือรูปแบบการทำงานของคลาสที่มีความสามมารถในการตรวจสอบสถานะภาพตัวของตัวเองได้อย่างอัตโนมัติ
เช่นการวางปุ่มลงในพื้นที่ฟอร์ม ก็จะปรากฏรูปสี่เหลี่ยมที่มองเป็นปุ่มกดตามขนาด และสีที่กำหนดไว้ก่อนหน้านี้
ข้อแนะนำ ในรายละเอียดการทำความรู้จักกับจาวาบีนมีรายละเอียดที่ค่อนข้างมากเกิดเนื้อหาของหนังสือ
หากท่านผู้อ่านสนใจในการสร้างจาวาบีนที่นอกเหนือจากเนื้อหา สามารถศึกษาเพิ่มเติมได้ที่ http://java.sun.com/javabean
สำหรับการใช้งานจาวาบีนกับเอกสาร JSP
ที่จะกล่าวถึงในบทเรียนนี้จะมุ่งเน้นให้ผู้อ่านได้ทำความรู้จักกับการสร้างคลาสที่สนับสนุนการทำงานของจาวาบีน
ซึ่งว่ากันตามจริงแล้วก็คือการสร้างคลาสโดยทั่วไปแต่คลาสดังกล่าวมีโครงสร้างที่สามารถจัดเก็บข้อมูลที่เชื่อมโยงกับเอกสาร JSP
ได้โดยอาศัยแท็กที่ทำงานเกี่ยวข้องกับจาวาบีนโดยเฉพาะ
รูปแสดงการใช้งานจาวาบีนร่วมกับเอกสาร JSP
เริ่มต้นผู้อ่านต้องเข้าใจก่อนว่าการสร้างจาวาบีนคือการสร้างคลาสเพื่อใช้งานร่วมกับเอกสา JSP ให้สามารถจัดเก็บข้อมูล
และอ่านข้อมูลที่อยู่ภายในคลาสได้ โดยผ่านแท็กคำสั่งในเอกสาร JSP ด้วยการสร้างคลาสในภาษาจาวาที่มีข้อกำหนดดังนี้
- หากมีการสร้างคอนสตรักเตอร์ให้กับคลาสที่เป็นจาวาบีน คอนสตรักเตอร์ดังกล่าวต้องไม่มีอาร์กิวเม็นต์
ซึ่งแน่นอนว่าคลาสทั่วไปที่สร้างโดยไม่ระบุคอนสตรักเตอร์ก็สามารถนำมาใช้งานเป็นจาวาบีนได้ เมื่อต้องการสร้างคลาส
MyBean เพื่อทำงานเป็นจาวาบีนควรมีรูปแบบอย่างใดอย่างหนึ่งดังนี้
รูปแบบคลาสจาวาบีนเมื่อมีคอนสตรักเตอร์
class Person {
Person() {
statements
}
…
}
รูปแบบคลาสจาวาบีนเมื่อไม่มีคอนสครักเตอร์
class Person {
…

3. }
- ในการจัดเก็บข้อมูลของจาวาบีนมีความหมายคือการจัดเก็บข้อมูลลงในแอตทริบิวต์ของคลาส
ซึ่งเมื้อมีการสร้างแอตทริบิวต์ของคลาสไม่ควรกำหนด Access Modifier หรือข้อกำหนดการเข้าถึงด้วยคีย์เวิร์ด public
เนื่องจากจาวาบีนจะไม่ยินยอมให้มีการอ้างถึงข้อมูลด้วยการอ้างชื่อแอตทริบิวต์โดยตรง
ซึ่งการเข้าถึงข้อมูลเพื่อกำหนดค่าหรืออ่านค่าในแอตทริบิวต์ต้องกระทำผ่านเมธอดเท่านั้น
ตัวอย่างของการสร้างแอตทริบิวต์ในคลาสจาวาบีนควรเป็นดังนี้
private String firstName;
private String lastName;
protected boolean married;
- การกำหนดค่าให้กับแอตทริบิวต์ให้ทำผ่านเมธอดจำพวกตั้งค่า คือเมธอดที่มีลักษณะการกำหนดชื่อเป็น setXxx
โดยมีการใช้คำว่า set เป็นคำแรกของชื่อเมธอด และใช้คำอื่นๆที่มีตัวอักษรตัวแรกเป็นตัวใหญ่นอกนั้นเป็นตัวอักษรใดๆ
(ส่วนใหญ่เป็นตัวเล็ก)วางไว้ตามหลัง จากนั้นเมธอดมีการกำหนด Access Modified โดยใช้คีย์เวิร์ด public
เพื่อให้สามารถเรียกใช้งานได้จากทุกๆส่วน และชนิดการคืนค่าด้วยคีย์เวิร์ด void
เนื่องจากไม่จำเป็นต้องคืนค่ากลับจากการใช้งาน เพราะเน้นไปที่การส่งค่ามากกว่า
สุดท้ายเมธอดนี้ต้องมีการส่งข้อมูลผ่านทางอาร์กิวเม็นต์ดังนั้นชนิดของอาร์กิวเม็นต์ก็จะเป็นชนิดเดียวกันกับชนิดของแอตทริ
บิวต์ ภายในเมธอดบรรจุคำสั่งเพื่อให้มีการนำเอาค่าที่ได้รับจากอาร์กิวเม็นต์ส่งไปบันทึกลงในแอตทริบิวต์ ดังตัวอย่างต่อไปนี้
public void setFirstName(String name) {
firstName = name;
}
public void setLastName(String name) {
lastName = name;
}
public void setMarried(boolean status) {
married = status;
}
- การอ่านค่าจากแอตทริบิวต์ก็ต้องทำผ่านเมธอดเช่นเดียวกับการกำหนดค่า
แต่เมธอดเป็นจำพวกอ่านค่าที่มีลักษณะการกำหนดชื่อเป็น getXxx โดยมีการใช้คำว่า get เป็นคำแรกของชื่อเมธอด
และใช้คำอื่นๆที่มีตัวอักษรตัวแรกเป็นตัวใหญ่นออกนั้นเป็นตัวอักษรใดๆวางไว้ด้านหลัง
เมธอดนี้ให้กำหนดการเข้าถึงด้วยคีย์เวิร์ด public
และชนิดการคืนค่าเป็นชนิดเดียวกับแอตทริบิวต์โดยไม่มีการระบุค่าอาร์กิวเม็นต์ให้กับเมธอด
ภายในเมธอดบรรจุคำสั่งเพื่อส่งค่าจากแอตทริบิวต์ออกไปใช้งาน ดังนั้นจึงต้องมีการใช้งานคำสั่ง return เพื่อทำหน้าที่
ตัวอย่างต่อไปนี้เป็นการสร้างเมธอดอ่านค่าเพื่อใช้งานกับแอตทริบิวต์ firstName คือ
public String getFirstName() {
return firstName;
}
public String getLastName() {
return lastName;
}
นอกจากจะมีการกำหนดเมธอดอ่านค่าด้วยการใช้รูปแบบการตั้งชื่อในแบบ getXxx แล้วยังใช้สามารถใช้รูปแบบ isXxx
ได้ด้วยในกรณีที่แอตทริบิวต์มีการเก็บข้อมูลในแบบ boolean การใช้คำแรกของชื่อเมธอดด้วยคำว่า is
จะสื่อความหมายได้ดีในกรณีที่ข้อมูลที่ต้องการอ่านเป็นแบบตรรกะ จากแอตทริบิวต์ที่กำหนดไว้คือ married จึงเป็นดังนี้
public boolean isMarried() {
return married;
}

4. ในการกำหนดเมธอดในการอ่านค่า ไม่จำเป็นที่จะต้องใช้สำหรับการอ่านค่าเพื่อส่งค่าจากแอตทริบิวต์ไปหาผู้รับเท่านั้น
ยังสามารถสร้างเมธอดโดยไม่จำเป็นต้องสัมพันธ์กับชื่อแอตทริบิวต์เลย
แต่เป็นเมธอดที่ส่งค่าคือหากมีการประมวลผลก็ได้แต่มีการตั้งชื่อเมธอดตามรูปแบบ getXxx หรือ isXxx เช่น
public String getFullName() {
return firstName + " " + lastName;
}
จากข้อกำหนดที่ได้ทำความเข้าใจเกี่ยวกับการสร้างคลาสในแบบจาวาบีนมาแล้ว
เมื่อสรุปตัวอย่างคลาสที่สามารถใช้งานเป็นจาวาบีนจากตัวอย่างที่ยกมาตั้งแต่ต้นเมื่อประกอบกันเป็นคลาสเพื่อใช้งานได้ควรเป็นดัง
นี้
1 package Beans
2 public class Person {
3 private String firstName;
4 private String lastName;
5 protected boolean married;
6
7 public void setFirstName(String name) {
8 firstName = name;
9 }
10 public void setLastName(String name) {
11 lastName = name;
12 }
13 public void setMarried(boolean status) {
14 married = status;
15 }
16 public String getFirstName() {
17 return firstName;
18 }
19 public String getLastName() {
20 return lastName;
21 }
22 public boolean isMarried() {
23 return married;
24 }
25 public String getFullName() {
26 return firstName + " " + lastName;
27 }
28 }
ตามตัวอย่างซอร์สโค้ดชื่อ Person.java หากพิจารณาดีๆแล้วจะเห็นว่าเป็นเพียงคลาสในรูปแบบจาวาทั่วไป
ซึ่งมีข้อกำหนดในการสร้างแอตทรบิวต์ และข้อกำหนดในการตั้งชื่อเมธอด
และสามารถนำคลาสมาใช้งานเพื่อสร้างเป็นอินสแตนซ์ได้เหมือนกับการใช้งานคลาสในภาษาจาวาทั่วไป
หากแต่ว่าคลาสนี้จะมีความสำคัญในเอกสาร JSP ต่อเมื่อมีการนำเอาไปใช้งาน ที่จะกล่าวในหัวข้อต่อไป
2. การใช้งานจาวาบีน
สำหรับการใช้งานคลาสในแบบจาวาบีนในเอกสาร JSP นั้น จำเป็นต้องอาศัยแท็ก jsp:xxx
ที่มีรูปแบบในการใช้งานตามข้อกำหนด XML แท็กที่ว่ามีชื่อที่แบ่งแยกออกไปตามการเรียกใช้จาวาบีน
ซึ่งมีลักษณะการใช้งานเหมือนกับการใช้งานคลาสในภาษาจาวาโดยทั่วไป ที่ต้องเริ่มต้นตั้งแต่การประกาศตัวแปร
การสร้างอินสแตนซ์ให้กับตัวแปร และการอ้างถึงเมธอดจากตัวแปร ซึ่งสามารถสรุปเป็นขั้นตอนของการใช้งานจาวาบีนในเอกสาร JSP
ได้ดังนี้
การติดตั้งคลาสจาวาบีน

5. ในการติดตั้งคลาสที่สร้างสำหรับทำงานเป็นจาวาบีนนี้ ผู้สร้างต้องติดตั้งคลาสในตำแหน่งเดียวกันกับการติดตั้งเซิร์ฟเล็ต
เนื่องจากเอกสาร JSP จะพิจารณาจาวาบีนในตำแหน่งเดียวกันกับเซิร์ฟเล็ต ดังนั้นจากคลาส Person
ที่มีการสร้างให้บรรจุอยู่ในแพ็กเกจชื่อ Beans ตามคำสั่งในบรรทัดที่ 1 ดังนั้นคลาสที่ได้รับจากการคอมไพล์คือ Person
ควรติดตั้งอยู่ในเว็บเซิร์ฟเวอร์ที่ได้ทำการทดสอบ ในเส้นทางดังนี้
C:Program FilesApache Tomcat 4.0webappsejpWEB-INFclassesBeansPerson.class
ดังนั้นเมื่อมีการอ้างถึงคลาสจากการใช้งานจาวาบีนควรอ้างผ่านชื่อแพ็กเกจคือ
Beans.Person
การสร้างตัวแปรและอินสแตนซ์ให้กับจาวาบีน
ในขั้นตอนนี้คือการอ้างถึงแท็ก jsp:useBean เพื่อใช้ในการกำหนดชื่อจาวาบีน และสร้างอินสแตนซ์ให้กับชื่อจาวาบีนดังกล่าว
ซึ่งต้องอ้างด้วยรูปแบบดังนี้
รูปแบบ
<jsp:useBean id="bean_name" class="bean_class" />
เมื่อ
bean_name คือชื่อที่จะใช้ตั้งเป็นชื่อจาวาบีน
bean_class คือชื่อคลาสที่สร้างตามรูปแบบจาวาบีน
ตัวอย่าง
<jsp:useBean id="man" class="Person" />
ตัวอย่างภาษาจาวา
Person man = new Person();
หากพิจารณาจากรูปแบบในการใช้งานจาวาบีนข้างต้นนั้น
จะเห็นว่าผู้สร้างจะต้องมีการกำหนดชื่อให้กับจาวาบีนในแอตทริบิวต์ id โดยชื่อนี้อาศัยกฎการตั้งชื่อเช่นเดียวกับที่ใช้ในภาษาจาวา
และมีการให้ชื่อคลาสจาวาบีนในส่วนแอตทริบิวต์ class จากตัวอย่างเป็นการสร้างจาวาบีนชื่อ man
โดยมีการอ้างไปยังอินสแตนซ์ตัวใหม่ที่สร้างจากคลาสชื่อ Person ที่ยกมาจากตัวอย่างในหัวข้อที่ผ่านมา
สำหรับในขั้นตอนนี้ของการใช้งานจาวาบีนก็เหมือนกับการสร้างตัวแปรและมีการสร้างอินสแตนซ์ให้ตัวแปรดังกล่าว
จากตัวอย่างที่แสดงไว้ด้านล่างเป็นการใช้คำสั่งในภาษาจาวา ซึ่งให้ผลลัพธ์เช่นเดียวกับการเขียนด้วยภาษาจาวา
ด้วยการนำเอาคำสั่งดังกล่าวมาวางไว้ในแท็กคำสั่งดำเนินงานภายในสัญลักษณ์ <% และ %>
การกำหนดค่าให้กับจาวาบีน
สำหรับในการทำงานส่วนนี้ คือการกำหนดค่าให้กับส่วนแอตทริบิวต์ในจาวาบีนที่สร้างขึ้นมา
แต่เนื่องจากแอตทริบิวต์ที่สร้างไว้ภายในคลาสไม่สามารถเข้าถึงได้โดยตรงดังนั้นจึงต้องกำหนดค่าผ่านเมธอดที่ได้กำหนดไว้
สำหรับการกำหนดค่าจาวาบีนในเอกสาร JSP มีการใช้งานแท็ก jsp ด้วยเช่นกัน แต่แท็กที่ใช้คือแท็กที่มีชื่อว่า jsp:setProperty
ให้พิจารณาจากรูปแบบการใช้งานดังต่อไปนี้
รูปแบบ
<jsp:setProperty name="bean_name" property="set_method" param="value" />
เมื่อ
bean_name คือชื่อจาวาบีน

6. set_method คือส่วนของชื่อเมธอดเฉพาะที่ตามหลังคำว่า set
value คือข้อมูลข้อความ (String) ที่จะถูกส่งให้กับแอตทริบิวต์ตามเมธอดที่อ้างไว้
ในแอตทริบิวต์ property ซึ่งจะแปลงข้อความไปเป็นชนิดที่ถูกกำหนดไว้ในเมธอดอัตโนมัติ
หากต้องการใส่ตัวอักษรพิเศษที่ใช้งานในการทำงานของแท็กในข้อมูล value
ข้อมูล ' ให้ใช้ ' แทน
ข้อมูล " ให้ใช้ " แทน
ข้อมูล ให้ใช้ แทน
ข้อมูล %> ให้ใช้ %> แทน
ข้อมูล <% ให้ใช้ <% แทน
ตัวอย่าง
<jsp:setProperty name="man" property="firstName" param="Rungrote" />
<jsp:setProperty name="man" property="lastName" param="Phonkam" />
<jsp:setProperty name="man" property="married" param="true" />
ตัวอย่างภาษาจาวา
man.setFirstName("Rungrote");
man.setLastName("Phonkam");
man.setMarried(true);
การกำหนดข้อมูลให้กับแอตทริบิวต์ของจาวาบีนให้ทำผ่านเมธอดที่ได้กำหนดไว้ในคลาส
ในส่วนเมธอดที่ใช้สำหรับการตั้งค่าที่ใช้ชื่อนำหน้าด้วยคำว่า set แต่สำหรับในการอ้างชื่อเมธอดดังกล่าวในเอกสาร JSP ด้วยแท็ก
jsp:setProperty นั้นหากดูในส่วนแอตทริบิวต์ name จะต้องระบุชื่อจาวาบีนที่ได้เคยกำหนดไว้จากแท็ก jsp:useBean มาก่อน
และเมื่อดูที่แอตทริบิวต์ property แล้วค่าที่ให้กับแอตทริบิวต์นี้เป็นชื่อเมธอดที่ตัดคำว่า set ออกไปและให้ตัวอักษรตัวแรกเป็นตัวเล็ก
เช่น หากกำหนดชื่อเมธอดตั้งค่าในคลาสเป็น setFirstName เมื่อตัดคำว่า set ออกไปจะเหลือเพียงคำว่า FirstName
แต่การนำมาใช้นั้นจะต้องใช้ตัวแรกเป็นตัวเล็กดังนั้นคำที่นำมาใช้จะเป็นคำว่า firstName
และเมื่อพิจารณาจากตัวอย่างการใช้งานแล้วตัวอย่างในบรรทัดแรกคือการผ่านค่า Rungrote
ให้กับแอตทริบิวต์ในจาวาบีนผ่านเมธอด setFirstName บรรทัดที่สองเป็นการผ่านค่า Phonkam ให้กับเมธอด setLastName
และบรรทัดที่สามเป็นการผ่านค่า true ให้กับเมธอด setMarried
และหากมีการกำหนดชื่อจาวาบีนมาก่อนแล้วจากแท็ก jsp:useBean นอกจากจะสามารถใช้แท็ก jsp:setProperty
ในการส่งค่าให้กับจาวาบีนได้แล้ว ยังสามารถนำเอาชื่อที่ตั้งไว้จากแท็ก jsp:useBean มาใช้งานกับคำสั่งภาษาจาวาปกติได้
ยกตัวอย่างเช่นเมื่อมีการกำหนดชื่อจาวาบีนชื่อ man ยังสามารถนำเอาชื่อนี้มาเรียกเมธอดได้เหมือนกับ 3
ตัวอย่างในส่วนล่างที่แสดงให้เห็น
การอ่านค่าจากจาวาบีน
ในการอ่านค่าจากแอตทริบิวต์หรือข้อมูลจากการทำงานในจาวาบีน
คือการเรียกใช้งานเมธอดในกลุ่มอ่านค่าที่ตั้งชื่อโดยการใช้คำว่า set หรือ is นำหน้าชื่อเมธอด และแท็กที่ใช้งานนี้คือแท็ก
jsp:getProperty โดยหากมีการวางแท็กนี้ไว้ในตำแหน่งใดของเอกสาร JSP ตำแหน่งดังกล่าวก็จะแสดงข้อมูลตามที่ได้รับมาจากแท็ก
รูปแบบ

7. <jsp:getProperty name="bean_name" property="get_method" />
เมื่อ
bean_name คือชื่อจาวาบีน
get_method คือส่วนของชื่อเมธอดเฉพาะที่ตามหลังคำว่า get หรือ is
ตัวอย่าง
<jsp:getProperty name="man" property="firstName" />
<jsp:getProperty name="man" property="lastName" />
<jsp:getProperty name="man" property="fullName" />
<jsp:getProperty name="man" property="married" />
ตัวอย่างภาษาจาวา
man.getFirstName();
man.getLastName();
man.getFullName();
man.isMarried();
จากรูปแบบการอ่านค่าของจาวาบีนทำผ่านเมธอดจำพวก get หรือ is ซึ่งจากแอตทริบิวต์ property ภายในแท็ก
jsp:getProperty ก็มีรูปแบบเหมือนกับการใช้ในแท็ก jsp:setProperty ซึ่งจากตัวอย่างที่ยกประกอบคำสั่งมี 4 ตัวอย่าง
ตัวอย่างแรกเป็นการใช้งานเมธอด getFirstName ตัวอย่างที่สองใช้งาน getLastName ตัวอย่างที่สามใช้งาน getFullName
ซึ่งเป็นเมธอดที่ได้จากการประมวลผลคำสั่ง (พิจารณาจากซอร์สโค้ดในการสร้างคลาส Person ประกอบ)
ซึ่งต่างจากเมธอดแรกที่เป็นการรับค่าแอตทริบิวต์โดยตรง (ชื่อเมธอดคล้ายชื่อแอตทริบิวต์)
ส่วนตัวอย่างสุดท้ายเป็นการเรียกใช้งานเมธอด isMarried
เช่นเดียวกันการอ่างแอตทริบิวต์ jsp:getPropery จะใช้งานต่อเมื่อมีการสร้างจาวาบีนจากแท็ก jsp:useBean
มาก่อนหน้านี้แล้ว และยังสามารถอ่านข้อมูลจากจาวาบีนผ่านการเขียนคำสั่งจาวาปกติได้เช่นกัน เหมือนกับตัวอย่างสุดท้าย 4
ตัวอย่างด้านล่างนั่นเอง
ตัวอย่างการใช้งานจาวาบีน
จากการสร้างจาวาบีน การใช้งานบีนในเอกสาร JSP ที่ได้กล่าวมาแล้วทั้งหมด ต่อไปนี้เป็นการนำเอาตัวอย่างคลาส Person
มาทดสอบการทำงานจากเอกสาร JSP ดังต่อไปนี้
1 <%@page contentType="text/html; charset=windows-874"%>
2 <html>
3 <head><title>Java Bean</title></head>
4 <jsp:useBean id="man" class="Beans.Person"/>
5 <jsp:setProperty name="man" property="firstName" value="Rungrote" />
6 <jsp:setProperty name="man" property="lastName" value="Phonkam" />
7 <jsp:setProperty name="man" property="married" value="true" />
8 <body>
9 <P><B> jsp</B></P>
10 First Name: <jsp:getProperty name="man" property="firstName" /><BR>
11 Last Name: <jsp:getProperty name="man" property="lastName" /><BR>
12 Full Name: <jsp:getProperty name="man" property="fullName" /><BR>
13 Married: <jsp:getProperty name="man" property="married" /><BR>
14 <HR>
15 <P><B> </B></P>
16 <%
17 man.setFirstName("Preeda");
18 man.setLastName("Chongkhodang");

8. 19 man.setMarried(false);
20 %>
21 First Name: <%=man.getFirstName()%><BR>
22 Last Name: <%=man.getLastName()%><BR>
23 Full Name: <%=man.getFullName()%><BR>
24 Married: <%=man.isMarried()%><BR>
25 </body>
26 </html>
จากตัวอย่างเอกสาร JSP ในไฟล์ BeanPerson.jsp เป็นการใช้งานคลาส Person ในแพ็กเกจ Beans
ที่สร้างตามข้อกำหนดของจาวาบีน ในบรรทัดที่ 4 เป็นการตั้งชื่อจาวาบีนชื่อ man ส่วนบรรทัดที่ 5 - 7
เป็นการตั้งค่าให้กับแอตทริบิวต์ในจาวาบีนผ่านเมธอดแบบต่างๆ ส่วนบรรทัดที่ 10 - 13
เป็นการอ่านค่าจากจาวาบีนมาแสดงในตำแหน่งของการเรียกใช้งาน
สำหรับในบรรทัดที่ 16 - 20 เป็นการใช้งานจาวาบีน man แต่เป็นการใช้ด้วยการใช้งานภาษาจาวาโดยตรง
เพื่อกำหนดค่าให้กับแอตทริบิวต์ผ่านเมธอด และบรรทัดที่ 21 - 24 เป็นการอ่านค่าจากจาวาบีนผ่านเมธอดโดยตรง
ซึ่งผลลัพธ์ของการทำงานในเอกสาร JSP เป็นดังนี้
รูปแสดงผลลัพธ์จากการทำงานของเอกสาร BeanPerson.jsp
3. จาวาบีนกับแท็ก JSP
ในการกำหนดค่าให้กับจาวาบีนด้วยแท็ก jsp:setProperty
ในการใช้งานจากตัวอย่างที่ผ่านมาเป็นการระบุค่าเป็นข้อความลงในแอตทริบิวต์ value โดยตรง
นอกจากจะระบุลงในซอร์สโค้ดโดยตรงแล้ว ผู้ใช้ยังสามารถผ่านข้อมูลสู่จาวาบีน
ได้โดยการใช้แท็กเอ็กเพลสชั่นช่วยในการส่งค่าจากการคำนวณหรือค่าจากพารามิเตอร์ได้
นอกจากนั้นแล้วยังบรรจุแท็กเอ็กเพลสชั่นลงในแอตทริบิวต์ name ได้ด้วยเช่นกัน ดังมีรูปแบบดังนี้
รูปแบบ
<jsp:setProperty name="<% expression %>" property="set_method" value="<% expression %>" />
set_method คือส่วนของชื่อเมธอดเฉพาะที่ตามหลังคำว่า set
expression คือในภาษาจาวา ที่ให้ผลลัพธ์เป็น String ซึ่งจะถูกแปลงไปเป็นชนิดเดียวกับที่ใช้ในเมธอด
หากใน expression มีการใช้สัญลักษณ์ " สามารถเปลี่ยนการใช้งาน

9. สัญลักษณ์ " ที่ใช้งานกับแอตทริบิวต์ name และ value ไปเป็น ' ได้
ลองพิจารณาตัวอย่างการใช้งานจาวาบีนจากการปรับปรุงเอกสาร JSP ชื่อ BeanPerson.jsp ไปเป็น BeanKid.jsp ดังต่อไปนี้
1 <%@page contentType="text/html; charset=windows-874"%>
2 <html>
3 <head><title>Java Bean Kid</title></head>
4 <body>
5 <P><B> URL:<%=request.getQueryString() %></B></P>
6 <jsp:useBean id="kid" class="Beans.Person"/>
7 <jsp:setProperty name="kid" property="firstName"
8 value='<%=request.getParameter("firstname")%>' />
9 <jsp:setProperty name="kid" property="lastName"
10 value='<%=request.getParameter("lastname")%>' />
11 First Name: <jsp:getProperty name="kid" property="firstName" /><BR>
12 Last Name: <jsp:getProperty name="kid" property="lastName" /><BR>
13 Full Name: <jsp:getProperty name="kid" property="fullName" /><BR>
14 </body>
15 </html>
เนื่องจากในซอร์สโค้ดบรรทัดที่ 8 และ 10 ในแอตทริบิวต์ value ซึ่งปกติจะใช้สัญลักษณ์ " ครอบข้อมูลที่ส่งให้กับจาวาบีน
แต่เนื่องจากในแท็กเอ็กเพลสชั่นต้องใช้สัญลักษณ์ " ในการเรียกใช้งานเมธอด getParameter ดังนั้นจึงเปลี่ยนสัญลักษณ์หลังแอตทริบิวต์
value จาก " ไปเป็น '
ส่วนรูปด้านล่างแสดงผลลัพธ์ที่ได้จากการทำงานเมื่อมีการเรียกใช้งานเอกสาร JSP
และมีการอ้างการใช้งานด้วยข้อมูลพารามิเตอร์บรรจุใน URL
รูปแสดงผลลัพธ์จากเอกสาร BeanKid.jsp
4. จาวาบีนฟอร์ม HTML
จากการใช้งานจาวาบีนเพื่อส่งผลลัพธ์เพื่อจัดเก็บในจาวาบีน ตัวอย่างที่ผ่านมาเป็นการอ่านข้อมูลพารามิเตอร์จาก URL
เข้าสู่จาวาบีน ตามที่ผู้อ่านได้ทราบมาแล้วว่าข้อมูลพารามิเตอร์สามารถส่งได้จากการป้อนผ่านฟอร์มในเอกสาร HTML ได้โดยตรง
ซึ่งสามารถเป็นได้ทั้งรูปแบบ GET ที่จะเห็นข้อมูลพารามิเตอร์ในช่อง URL หรือรูปแบบ POST
ที่จะส่งข้อมูลพารามิเตอร์ผ่านข้อมูลร้องข้อส่วนหัว สำหรับแท็ก jsp:setProperty มีแอตทริบิวต์ชื่อ param
ซึ่งจะช่วยให้เกิดความสะดวกในการนำพาเอาข้อมูลพารามิเตอร์ไม่ว่ากรณีใดๆ ส่งให้กับจาวาบีน
โดยผู้ใช้ไม่จำเป็นต้องอ้างด้วยแท็กเอ็กเพลสชั่นเหมือนในตัวอย่างที่กล่าวมา

10. รูปแบบ
<jsp:setProperty name="bean_name" property="set_method" param="form_field" />
เมื่อ
param คือชื่อฟิลด์ที่ใช้ในฟอร์มของเอกสาร HTML ซึ่งจะแปลงข้อมูลสู่จาวาบีน
เพื่อให้เกิดความเข้าใจในการใช้งานฟอร์มเอกสาร HTML เพื่อส่งข้อมูลจากการป้อน
ขอแนะนำตัวอย่างของจาวาบีนตัวใหม่ที่ชื่อ BeanPhone ในแพ็กเกจ Beans ของไฟล์ BeanPhone.java
คลาสดังกล่าวบรรจุแอตทริบิวต์คือ phoneNumber และ phoneName เมธอดจำพวก setXxx คือ setPhoneNumber และ
setPhoneName สุดท้ายคือเมธอดจำพวก getXxx คือ getPhoneNumber, getPhoneName และ getPhoneInfo ดังต่อไปนี้
1 package Beans;
2 public class BeanPhone {
3 private String phoneNumber = "";
4 private String phoneName = "";
5
6 public void setPhoneNumber(String pnumber) {
7 phoneNumber = pnumber;
8 }
9 public String getPhoneNumber() {
10 return phoneNumber;
11 }
12 public void setPhoneName(String pname) {
13 phoneName = pname;
14 }
15 public String getPhoneName() {
16 return phoneName;
17 }
18 public String getPhoneInfo() {
19 return "Name: " + phoneName + "<BR>Number: " + phoneNumber;
20 }
21 }
ตัวอย่างต่อไปเป็นเอกสาร HTML ในไฟล์ BeanPhoneForm1.html
1 <html>
2 <head><title>Bean Phone 1</title></head>
3 <body bgcolor="#FFFFFF">
4 <FORM method="POST" action="BeanPhoneFields.jsp">
5 Name:
6 <INPUT TYPE="TEXT" NAME="phone_name"><BR>
7 Phone Number:
8 <INPUT TYPE="TEXT" NAME="phone_number"><BR>
9 <INPUT TYPE="submit" NAME="Submit" VALUE="Submit">
10 </FORM>
11 </body>
12 </html>
จากตัวอย่างเป็นเอกสาร HTML ที่ใช้ในการสร้างฟอร์มกรอกข้อมูลเพื่อส่งข้อมูลเป็นพารามิเตอร์ให้กับเอกสาร JSP ชื่อ
BeanPhoneFields.jsp ในฟอร์มประกอบด้วยช่องกรอกข้อมูล 2 ช่องโดยมีการกำหนดชื่อฟิลด์เป็น phone_name และ
phone_number ตามลำดับ ซึ่งเมื่อผู้ใช้ป้อนข้อมูลในช่องกรอกข้อมูลทั้งสอง ชื่อที่ฟิลด์ของช่องกรอกข้อมูลจะถูกนำไปใช้ในเอกสาร
JSP เพื่ออ้างถึงและอ่านข้อมูลเพื่อส่งให้กับจาวาบีนต่อไป

11. รูปแสดงฟอร์มที่ได้จากการทำงานของเอกสาร BeanPhoneForm1.html
1 <%@page contentType="text/html; charset=Windows-874"%>
2 <html>
3 <head><title>Read Form Field to JavaBean</title></head>
4 <jsp:useBean id="MyPhone" class="Beans.BeanPhone" />
5 <jsp:setProperty name="MyPhone" property="phoneName" param="phone_name" />
6 <jsp:setProperty name="MyPhone" property="phoneNumber" param="phone_number" />
7 <body>
8 <P><B> JavaBean</B></P>
9 <jsp:getProperty name="MyPhone" property="phoneName"/>
10 <jsp:getProperty name="MyPhone" property="phoneNumber"/>
11 <HR>
12 <jsp:getProperty name="MyPhone" property="phoneInfo"/>
13 </body>
14 </html>
จากตัวอย่างเอกสาร JSP ชื่อ BeanPhoneFields.jsp ทำงานเมื่อได้รับข้อมูลจากฟอร์มเอกสารของเอกสาร HTML ชื่อ
BeanPhoneForm1.html จะเห็นว่าในบรรทัดที่ 4 เป็นการกำหนดชื่อจาวาบีนชื่อ MyPhone โดยอ้างถึงคลาส BeanPhone ในแพ็กเกจ
Beans ส่วนบรรทัดที่ 5 และ 6 มีการกำหนดแอตทริบิวต์ param ในแท็ก jsp:serProperty
โดยการอ้างด้วยชื่อฟิลด์ที่กำหนดไว้ในชื่อช่องกรอกข้อมูล ซึ่ง ณ.จุดนี้จะเกิดการทำงานโดยการดึงข้อมูลในฟิลด์ดังกล่าว
ส่งให้กับจาวาบีนผ่านเมธอดที่อ้างจากแอตทริบิวต์ property ในแท็กเดียวกัน เพื่อให้เห็นถึงผลการทำงานลองพิจารณาจากรูปต่อไปนี้
ซึ่งรูปแรกเป็นการป้อนข้อมูล Rungrote ลงในช่องกรอกข้อมูลที่ชื่อ phone_name และหมายเลขโทรศัพท์ในช่องกรอกข้อมูลชื่อ
phone_number ซึ่งหลังจากคลิกปุ่ม Submit ข้อมูลดังกล่าวจะถูกส่งไปสู่จาวาบีนชื่อ MyPhone
และผลลัพธ์ที่ได้จาการทำงานดูได้จากรูปต่อมา
รูปแสดงการกรอกข้อมูลลงในฟอร์มของเอกสาร BeanPhoneForm1.html
รูปแสดงผลลัพธ์จากเอกสาร BeanPhoneFields.jsp
ข้อแนะนำ หากไม่มีการป้อนข้อมูลลงในฟิลด์ของช่องกรอกข้อมูล จะไม่มีการส่งค่า null ให้กับจาวาบีน นั้นหมายถึงในเอกสาร JSP
ที่มีแท็ก jsp:setProperty ที่อ้างถึงฟิลด์ที่ไม่ได้กรอกข้อมูลจะไม่มีการทำงานใดๆเกิดขึ้น

12. จากตัวอย่างที่แสดงให้เห็นเป็นการสร้างฟอร์มที่บรรจุฟิลด์ไม่กี่จำนวน แต่หากมีการสร้างฟอร์มที่มีจำนวนฟิลด์ค่อนข้างมาก
เพื่อให้เกิดความสะดวกมากยิ่งขึ้น หากชื่อฟอร์มที่ตั้งขึ้นตรงกับชื่อที่ใช้ในการอ้างถึงของแอตทริบิวต์ property ในเมธอดจำพวก setXxx
แล้ว มีวิธีการอ้างเพื่อให้ข้อมูลในฟอร์มที่มีชื่อเดียวกันนั้นส่งให้กับจาวาบีนในทุกๆ ด้วยรูปแบบดังนี้
รูปแบบ
<jsp:setProperty name="bean_name" property="*" />
เมื่อ
สัญลักษณ์ * ในแอตทริบิวต์ property เป็นการอ่านข้อมูลในทุกๆฟิลด์ของฟอร์มที่มีชื่อเดียวกันกับการอ้างเพื่อใช้
ในเมธอด setXxx
ลองพิจารณาเอกสาร HTML ในไฟล์ BeanPhoneForm2.html ต่อไปนี้
1 <html>
2 <head><title>Bean Phone Form 2</title></head>
3 <body bgcolor="#FFFFFF">
4 <FORM method="POST" action="BeanPhoneAllFields.jsp">
5 Name:
6 <INPUT TYPE="TEXT" NAME="phoneName"><BR>
7 Phone Number:
8 <INPUT TYPE="TEXT" NAME="phoneNumber"><BR>
9 <INPUT TYPE="submit" NAME="Submit" VALUE="Submit">
10 </FORM>
11 </body>
12 </html>
จากข้อสังเกตในเอกสารข้างต้นเป็นการสำเนาเอาเอกสาร BeanPhoneForm1.html
มาใช้งานโดยมีการเปลี่ยนแปลงการตั้งชื่อฟิลด์ในช่องกรอกข้อมูลของบรรทัดที่ 6 และ 8 ไปเป็น phoneName และ phoneNumber
ตามลำดับ ซึ่งชื่อที่ตั้งขึ้นหากมีการใช้งานแอตทริบิวต์ property ในแท็ก jsp:setProperty จะเป็นชื่อเดียวกัน
ดังนั้นจึงสามารถใช้กฎเกณฑ์เพื่อให้เกิดความสะดวกในเอกสาร BeanPhoneAllFields.jsp
เพื่อให้มีการส่งข้อมูลลงสู่จาวาบีนโดยอัตโนมัติดังนี้
1 <%@page contentType="text/html; charset=Windows-874"%>
2 <html>
3 <head><title>Read all Fields into JavaBean</title></head>
4 <jsp:useBean id="MyPhone" class=" Beans.BeanPhone" />
5 <jsp:setProperty name="MyPhone" property="*" />
6 <body>
7 <P><B>
JavaBean</B></P>
8 <jsp:getProperty name="MyPhone" property="phoneName" />
9 <jsp:getProperty name="MyPhone" property="phoneNumber" />
10 <HR>
11 <jsp:getProperty name="MyPhone" property="phoneInfo" />
12 </body>
13 </html>
จากตัวอย่างเอกสาร JSP ข้างต้นในบรรทัดที่ 5 มีการเรียกใช้แท็ก jsp:setProperty ที่อ้างถึงแอตทริบิวต์ property
ด้วยสัญลักษณ์ * เพื่อส่งข้อมูลในทุกฟิลด์ของฟอร์มไปสู่จาวาบีน ส่วนในบรรทัดที่ 8, 9 และ 11
เป็นการอ่านข้อมูลในจาวาบีนมาแสดงด้วยแท็ก jsp:getProperty ตามลำดับ
5. ช่วงเวลาในการใช้งานจาวาบีน
เนื่องจากเมื่อมีการใช้งานแท็ก jsp:useBean แล้วชื่อจาวาบีนที่สร้างขึ้นมาจะเหมือนกับการตั้งชื่อตัวแปรในภาษาจาวา
ดังนั้นชื่อจาวาบีนดังกล่าวจึงสามารถนำมาใช้งานได้ในทุกๆตำแหน่งของเอกสาร JSP เดียวกัน แต่เนื่องจากแท็ก jsp:useBean

13. มีข้อกำหนดพิเศษที่ช่วยทำให้ชื่อจาวาบีนสามารถอ้างเพื่อใช้งานได้มากกว่าภายในเอกสารเดียวกันด้วยแอตทริบิวต์ scope
ดังมีรูปแบบดังนี้
รูปแบบ
<jsp:useBean id="bean_name" class="bean_class" scope="scope_name" />
เมื่อ
scope_name คือชื่อที่ใช้กำหนดช่วงเวลาที่สามารถใช้งานจาวาบีนได้ดังนี้
page สำหรับกำหนดให้ใช้งานได้ในเอกสารเดียวกัน
จาวาบีนจะสร้างไว้ออปเจ็คเก็บไว้เป็นตัวแปรภายในเอกสารเท่านั้น
อ้างได้จากชื่อจาวาบีนโดยตรงจากชื่อจาวาบีน
application สำหรับกำหนดให้ใช้งานได้ในแอปพลิเคชั่นบนเว็บเดียวกัน
จากตัวอย่างที่ใช้ในหนังสือคือ ใช้งานได้ในทุกเอกสารที่อยู่ในเส้นทาง ejp
จาวาบีนจะสร้างเป็นออปเจ็คส่งให้กับ ServletContext เก็บไว้
และอ้างได้จากเมธอด getServletContext()
session สำหรับกำหนดให้ใช้งานได้ต่อการใช้งานของผู้ใช้ในบราวเซอร์
มีลักษณะเช่นเดียวกันกับการใช้งานเซสชั่นที่เคยกล่าวไว้ในการสร้างเซิร์ฟเล็ต
จาวาบีนจะสร้างเป็นออปเจ็คเก็บไว้ใน HttpSession
และอ้างได้จากเมธอด getValue()
request สำหรับกำหนดไว้ให้ใช้งานได้จากข้อมูลร้องขอของผู้ใช้
จาวาบีนจะสร้างเป็นออปเจ็คส่งให้กับ ServletRequest เก็บไว้
และอ้างได้จากเมธอด getAttribute ()
6. ความหมายของแท็กไลบรารี่
ตามความหมายของคำว่าแท็กที่ได้เคยอธิบายไว้ว่า
แท็กคือคำสั่งที่บรรจุลงในเอกสารเพื่อบ่งบอกวัตถุประสงค์ในการทำงานกับข้อมูล เช่น แท็ก HTMl ใช้สำหรับนำเสนอเอกสาร แท็ก XML
สำหรับกำหนดโครงสร้างของเอกสาร แท็ก JSP ที่สามารถทำให้มีการประมวลผลเกิดขึ้นแต่เป็นการใช้แท็กคำสั่งตามที่กำหนดไว้
สำหรับแท็กที่จะกล่าวถึงในที่นี้เป็นแท็กที่ทำให้เกิดการประมวลผลได้ในเอกสาร JSP
และสามารถกำหนดชื่อแท็กได้ตามความต้องการของผู้สร้างโปรแกรม แท็กดังกล่าวยังสามารถทำงานได้กับคลาสที่สร้างจากภาษาจาวา
แท็กนี้รวมเรียกในการทำงานกับเอกสาร JSP ว่าแท็กไลบรารี่ (Tag Library)
รูปการทำงานของแท็กไลบรารี่
จากรูปอธิบายถึงการทำงานของแท็กไลบรารี่ที่จำเป็นต้องมีการกำหนดเอกสารบ่งบอกชื่อแท็ก
มีการสร้างคลาสเพื่อรองรับการทำงานเมื่อมีการใช้งานชื่อแท็กดังกล่าว สำหรับในขั้นตอนการทำงานของแท็กไลบรารี่เกิดจากเอกสาร
JSP ที่มีการเรียกใช้งานแท็กที่กำหนดไว้เพื่อดึงเอาคลาสที่กำหนดไว้มาทำงานและประมวลผลตามความต้องการของผู้สร้าง

14. ซึ่งแท็กไลบรารี่จะคล้ายกันกับจาวาบีน แต่ต่างที่จาวาบีนต้องใช้แท็กที่กำหนดไว้ก่อนหน้านี้แล้วคือ jsp:useBean, jsp:setProperty และ
jsp:getProperty และคลาสที่ทำงานเป็นจาวาบีนก็เน้นที่การจัดเก็บข้อมูล และการประมวลผลในบางส่วน
ในขณะที่แท็กไลบรารีผู้ใช้สามารถกำหนดชื่อแท็กได้ด้วยตนเอง และสามารถสร้างคลาสเพื่อให้ทำงานตามการใช้งานแท็กได้
และคำว่าไลบรารี่ก็มีความหมายถึงการนำเอาแท็กหลายแท็กที่ทำงานร่วมกันได้เก็บไว้เพื่อใช้งานนั่นเอง
7. การสร้างแท็กไลบรารี่สำหรับแท็กเปล่า
ในขั้นตอนการสร้างแท็กไลบรารี่ ผู้สร้างต้องทำความเข้าใจก่อนว่าลักษณะของแท็กที่ใช้กันเป็นรูปแบบใด
สำหรับแท็กที่จะใช้เป็นแท็กไลบรารี่จะมีรูปแบบตามข้อกำหนดของ XML
ดังนั้นเพื่อให้สามารถกำหนดวิธีการจัดสร้างแท็กได้อย่างถูกต้อง ในเนื้อหาต่อไปจากนี้
ผู้เขียนจะค่อยๆแนะนำให้ผู้อ่านได้รู้จักการสร้างแท็กในแบบง่ายๆ จนถึงแท็กที่มีความซับซ้อน
แต่สำหรับตอนนี้ลองพิจารณารูปแบบของแท็กโดยทั่วไปกันก่อนว่ามีลักษณะอย่างไร
รูปแบบของแท็กเปล่า
<tag_name attribute="value" />
เมื่อ
<…/> คือลักษณะของแท็กเปล่า
tag_name คือชื่อคำสั่งในแท็ก
attribute คือชื่อแอตทริบิวต์ ในบางแท็กอาจไม่ต้องการแอตทริบิวต์ บางแท็กอาจต้องการแอตทริบิวต์
value คือค่าที่กำหนดให้กับแอตทริบิวต์
สำหรับแท็กแบบแรกที่เราจะสร้างขึ้นนั้นเป็นแท็กที่เรียกว่าแท็กเปล่าที่ไม่มีการกำหนดแอตทริบิวต์ให้กับแท็ก
ซึ่งถือเป็นรูปแบบที่ง่ายที่สุดในการทำงานของการสร้างแท็ก แท็กที่ว่ามีรูปแบบดังนี้
รูปแบบ แท็กเปล่าที่ไม่มีแอตทริบิวต์
<tag_name />
ก่อนที่เราจะเริ่มสร้างแท็กขึ้นเพื่อใช้งานกัน ต้องเข้าใจขั้นตอนและวิธีในการสร้างแท็กให้เป็นแท็กไลบรารี่กันก่อน
เริ่มต้นจากการสร้างคลาสให้สามารถทำงานเมื่อมีการเรียกใช้แท็ก ขั้นต่อไปคือการกำหนดชื่อให้กับแท็ก
และในขั้นตอนสุดท้ายคือการใช้งานแท็กในเอกสาร JSP
ซึ่งในแต่ละขั้นตอนนั้นเราจะนำมาสร้างแท็กเปล่าที่ไม่มีแอตทริบิวต์ที่ละขั้นดังต่อไปนี้
ขั้นที่ 1 สร้างคลาสเพื่อประมวลผลแท็ก
โดยในขั้นตอนแรกเริ่มด้วยการสร้างคลาสใหม่ที่จะนำมาใช้งานเพื่อรองรับการทำงานของแท็กที่ต้องการสร้างขึ้นก่อน
ด้วยการสร้างคลาสใดๆที่สืบทอดมาจากคลาสชื่อ TagSupport
ซึ่งคลาสนี้ถูกกำหนดไว้สำหรับการใช้สร้างคลาสเพื่อทำงานในรูปแบบแท็กไลบรารี่โดยเฉพาะ
จากนั้นในคลาสใหม่ที่สร้างขึ้นมาให้วางเมธอดที่ชื่อ doStartTag เพื่อใช้ทำงานเมื่อมีการใช้งานในแท็ก
จากนั้นบรรจุคำสั่งต่างๆลงในเมธอดดังกล่าว โดยมีรูปแบบการสร้างดังนี้
รูปแบบซอร์สโค้ดเพื่อการสร้างคลาสสนับสนุนการทำงานของแท็กเปล่า
import javax.servlet.jsp.tagext.*;
class class_name extends TagSupport {
…
public int doStartTag() {

15. …
return (SKIP_BODY);
}
}
เนื่องจากว่าคลาส TagSupport บรรจุอยู่ในแพ็กเกจ javax.servlet.jsp.tagext
ดังนั้นจึงจำเป็นต้องอิมพอร์ตแพ็กเกจดังกล่าวเพื่อใช้งานในส่วนต้นของซอร์สโค้ด
สิ่งหนึ่งที่อยากให้ผู้อ่านลองสังเกตจากโครงสร้างซอร์สโค้ดเป็นพิเศษคือภายในเมธอด doStartTag ที่บรรจุคำสั่งในการทำงานลงไป
จะเห็นว่าเมื่อต้องการจบการทำงานของเมธอดต้องคืนค่าข้อมูลจากตัวแปรค่าคงที่ที่ชื่อ SKIP_BODY
ซึ่งเป็นตัวแปรค่าคงที่ที่บรรจุอยู่ในคลาส TagSupport
การคืนค่าด้วยตัวแปรดังกล่าวเพื่อให้คลาสมีการทำงานโดยละเว้นข้อมูลอื่นๆของแท็ก
(ในที่นี้คือข้อมูลระหว่าแท็กเปิดและแท็กปิดไม่ถูกพิจารณา เนื่องจากเป็นตัวอย่างการสร้างแท็กเปล่า)
การคือค่านี้เป็นสิ่งที่สำคัญอย่างยิ่งในการสร้างคลาสที่ต้องการเพื่อให้ใช้งานกับแท็กเปล่า
1 package Tags;
2
3 import javax.servlet.jsp.*;
4 import javax.servlet.jsp.tagext.*;
5 import java.io.*;
6
7 public class TagSay1 extends TagSupport {
8 private String say1 = "Sawadee";
9
10 public int doStartTag() {
11 try {
12 JspWriter out = pageContext.getOut();
13 out.print(say1);
14 } catch (IOException e) {
15 System.out.println(e);
16 }
17 return (SKIP_BODY);
18 }
19 }
จากซอร์สโค้ดด้านเป็นเป็นการสร้างคลาสที่ชื่อ TagSay1 ในไฟล์ TagSay1.java เพื่อให้รองรับการทำงานเมื่อมีการใช้งานแท็ก
(ตอนนี้ยังไม่ได้กำหนดชื่อแท็ก) เมื่อพิจารณาจากเมธอด doStartTag ในบรรทัดที่ 12 มีการสร้างตัวแปร out ที่รับข้อมูลมาจาก
pageContext.getOut() ตัวแปร out มีโครงสร้างมาจากการทำงานของคลาส JspWriter
เพื่อใช้จัดการการส่งข้อมูลไปวางในตำแหน่งที่แท็กวางอยู่ ซึ่งสามารถแสดงตัวอักษรด้วยการเรียกใช้งานเมธอด print หรือ println
อย่างใดอย่างหนึ่ง และในบรรทัดที่ 13 เป็นการนำเอาข้อมูลในตัวแปร say1 ซึ่งก็คือข้อความ Sawadee ไปแสดงนั่นเอง
เนื่องจากการใช้งานคลาส JspWrite ที่มีการทำงานเกี่ยวกับด้าน IO ดังนั้นจึงต้องควบคุมเอ็กเซพชั่น (Exception Handling)
ด้วยกลุ่มคำสั่ง try…catch ด้วย และสุดท้ายที่ลืมไม่ได้เลยคือการคืนค่า SKIP_BODY ที่แสดงให้เห็นในบรรทัดที่ 17
เมื่อคอมไพล์ซอร์สโค้ดดังกล่าวแล้วจะได้ไฟล์ TagSay.class ในแพ็กเกจ Tags มาถึงขั้นตอนการติดตั้งคลาสเพื่อใช้งาน
เนื่องจากการใช้งานคลาสใดๆในเอกสาร JSP นั้นจะทำงานในเส้นทางเหมือนกับที่ทำงานกับจาวาบีน
ดังนั้นจากเส้นทางการใช้งานเว็บแอปพลิเคชั่นในหนังสือคือ ejp ดังนั้นเส้นทางในการวางคลาสจะเป็นดังนี้
C:Program FilesApache Tomcat 4.0webappsejpWEB-INFclassesTagsTagSay.class
ขั้นที่ 2 สร้างเอกสารข้อกำหนดแท็ก

16. ในขั้นตอนที่สองนี้เป็นการกำหนดชื่อแท็ก เพื่อให้ส่งการทำงานไปยังคลาสที่สร้างไว้ในขั้นตอนแรก
ในการกำหนดชื่อคลาสมีการสร้างไฟล์ที่ใช้กำหนดอธิบายส่วนประกอบของแท็ก เช่น ชื่อ การนำไปใช้งาน การอ้างอิงคลาส เป็นต้น
ไฟล์ดังกล่าวเป็นไฟล์ที่มีนามสกุล .tld ที่บรรจุตัวอักษรทั่วไป ต่อไปจะเรียกเอกสารนี้ว่าเอกสาร TLD ซึ่งมาจาก Tag Library Descriptor
รูปแบบเอกสารข้อกำหนดแท็ก
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE taglib PUBLIC "-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.1//EN"
"http://java.sun.com/j2ee/dtd/web-jsptaglibrary_1_2.dtd">
<taglib>
<tlibversion>lib_version</tlibversion>
<jspversion>jsp_version</jspversion>
<shortname>short_name</shortname>
<uri></uri>
<info>lib_description</info>
<tag>
<name>tag_name</name>
<tagclass>class_reference </tagclass>
<bodycontent>EMPTY</bodycontent>
<info>tag_description</info>
</tag>
</taglib>
เมื่อ
<taglib>…</taglib> คืออิลิเม็นต็ข้อกำหนดแท็กไลบราลี่
lib_version คือเวอร์ชันของการสร้างแท็กไลบราลี่
jsp_version คือเวอร์ชันของการทำงานตามข้อกำหนดของ JSP
short_name คือชื่อสั้นๆที่ใช้อ้างถึงแท็กไลบราลี่
lib_description คือข้อความใช้อธิบายการทำงานของแท็ก
<tag></tag> คืออิลิเม็นต์ข้อกำหนดแต่ละแท็ก
tag_name คือชื่อแท็ก
class_reference คือชื่อคลาสที่อ้างถึงเพื่อประมวลผล
tag_description คือข้อความใช้อธิบายแท็ก
จากตัวอย่างโครงสร้างของเอกสารเป็นข้อกำหนดเพื่อใช้ในการสร้างเอกสาร TLD
ซึ่งเป็นโครงสร้างผู้สร้างจำเป็นต้องระมัดระวังในการสร้างพอสมควร เนื่องจากตัวเอกสารมีข้อกำหนดตามลักษณะของ XML
ดังนั้นหากมีข้อผิดพลาดขึ้นจะทำให้เอกสาร JSP ที่ต้องการใช้แท็กไม่สามารถเรียกใช้คลาสขึ้นทำงานได้
1 <?xml version="1.0" encoding="UTF-8" ?>
2
3 <!DOCTYPE taglib

17. 4 PUBLIC "-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.1//EN"
5 "http://java.sun.com/j2ee/dtd/web-jsptaglibrary_1_2.dtd">
6 <!-- a tag library descriptor -->
7
8 <taglib>
9 <tlibversion>1.0</tlibversion>
10 <jspversion>1.2</jspversion>
11 <shortname>ejp</shortname>
12 <uri></uri>
13 <info>A Tag Library from EJP</info>
14
15 <tag>
16 <name>say1</name>
17 <tagclass>Tags.TagSay1</tagclass>
18 <bodycontent>EMPTY</bodycontent>
19 <info>Tag to say</info>
20 </tag>
21
22 </taglib>
จากตัวอย่างคือเอกสาร TLD ที่ชื่อ ejp-taglib.tld เพื่อใช้สำหรับอธิบายข้อกำหนดของแท็ก
เมื่อพิจารณาจากตัวอย่างในบรรทัดที่เป็นตัวเอียงคือบรรทัดที่ 8 - 13 และบรรทัดที่ 22
ซึ่งใช้อธิบายแท็กไลบรารีพอสรุปว่าเป็นแท็กไลบรารี่ที่สร้างไว้ในเวอร์ชัน 1.0 ตามข้อกำหนดเอกสาร JSP 1.2 มีชื่อสั้นอ้างว่า ejp
และมีคำอธิบายแท็กไลบรารีว่า A Tag Library from EJP
จะเห็นว่าแท็กไลบรารีมีการครอบข้อกำหนดตัวแท็ก (สังเกตจากอักษรตัวหนาในบรรทัดที่ 15 - 20 ) มีการกำหนดชื่อแท็กว่า
say1 (บรรทัดที่ 16) โดยส่งการทำงานไปให้คลาส TagSay1 จากแพ็กเกจ Tags (บรรทัดที่ 17) และในอิลิเม็นต์ bodycontent (บรรทัดที่
18) มีข้อความว่า EMPTY ซึ่งเป็นส่วนหนึ่งที่ใช้บอกว่าแท็ก say1 นี้เป็นแท็กเปล่า
(ซึ่งเอกสารนี้กำหนดสอดคล้องกับซอร์สโค้ดที่ต้องคืนค่า SKIP_BODY ในเมธอด doStartTag
การวางตำแหน่งของเอกสาร TLD นี้ จำเป็นต้องวางตำแหน่งไว้ในที่ที่เอกสาร JSP สามารถอ้างถึงได้โดยง่าย
ดังนั้นในการทดสอบของหนังสือได้ว่างไฟล์ไว้ในเส้นทางต่อไปนี้
C:Program FilesApache Tomcat 4.0webappsejpejp-taglib.tld
ขั้นที่ 3 สร้างเอกสาร JSP เพื่อใช้งานแท็ก
เมื่อผ่านขั้นตอนทั้งสองขั้นตอนแล้วก็สามารถใช้งานแท็กได้ และในขั้นตอนสุดท้ายนี้เป็นการสร้างเอกสาร JSP
ขึ้นมาเพื่อทดสอบการใช้งานแท็กชื่อ say1 ว่าจะมีการเรียกการทำงานของคลาส TagSay1 หรือไม่ โดยในเอกสาร JSP
ต้องมีการใช้งานแท็กไดเร็กทีฟ taglib เพื่อกำหนดการอ้างชื่อแท็กจากเอกสาร TLD ดังนี้
รูปแบบการเรียกใช้งานข้อกำหนดแท็ก
<%@taglib uri="tld_file" prefix="prefix_name" %>
รูปแบบการเรียกใช้งานแท็กเปล่า
<prefix_name:tag_name />
เมื่อ
tld_file คือชื่อไฟล์เอกสาร TLD
prefix_name คือชื่อต้นที่กำหนดไว้เพื่อใช้งานแท็ก เนื่องจากในเอกสาร JSP สามารถใช้งานแท็กได้จาก
หลายไฟล์ข้อกำหนด ดังนั้นจึงต้องใช้ชื่อต้นเพื่อบอกว่าใช้จากเอกสารใด

18. tag_name คือชื่อแท็กที่กำหนดไว้ในเอกสาร TLD
จากคลาส TagSay1 ที่สร้างไว้ในขั้นที่ 1 และเอกสาร ejp-taglib.tld ที่สร้างไว้ในขั้นที่ 2 จากนี้เป็นตัวอย่างเอกสาร JSP
ที่มีการใช้งานแท็กไลบรารี่ที่สร้างขึ้นมา
1 <%@page contentType="text/html; charset=windows-874"%>
2 <html>
3 <%@taglib uri="ejp-taglib.tld" prefix="guy" %>
4 <head><title><guy:say1 /> </title></head>
5 <body>
6 <guy:say1 />
7 </body>
8 </html>
จากตัวอย่างเอกสาร JSP ชื่อ TagSay1.jsp เป็นการใช้งานแท็กที่ได้สร้างขึ้นมา สังเกตจากบรรทัดที่ 3
เป็นการเรียกใช้งานแท็กที่บรรจุในเอกสาร TLD และเมื่อใช้งานแท็กใดๆในเอกสารให้อ้างชื้อต้นด้วยคำว่า guy ในบรรทัดที่ 4 และ 6
มีการใช้งานแท็ก say ซึ่งตำแหน่งดังกล่าวจะประกฎคำว่า Sawadee ในส่วนแถบไตเติลและพื้นที่แสดงข้อมูลของบราวเซอร์
ซึ่งเกิดจากการทำงานของคลาส TagSay1 นั่นเอง
รูปแสดงการทำงานจากแท็กไลบรารี่บนเอกสาร TagSay1.jsp
8. การสร้างแท็กเปล่าที่มีแอตทริบิวต์
ต่อไปนี้เป็นการสร้างแท็กที่มีข้อกำหนดมากขึ้นก็คือการมีแอตทริบิวต์เพื่อส่งข้อมูลไปสู่คลาสในการทำงาน
แต่ถึงอย่างไรตอนนี้ก็ยังเป็นการสร้างแท็กเปล่าอยู่เช่นเดิม โดยแท็กเปล่าที่มีแอตทริบิวต์มีรูปแบบการใช้งานดังนี้
รูปแบบ แท็กเปล่าที่ไม่มีแอตทริบิวต์
<tag_name attribute1="value1" attribute2="value2" …/>
เมื่อ
tag_name คือชื่อแท็ก
attribute1, attribute2 คือชื่อแอตทริบิวต์
value1, value2 คือข้อมูลที่ต้องการส่งให้กับแอตทริบิวต์
ขั้นที่ 1 สร้างคลาสเพื่อประมวลผลแท็ก
สำหรับในขั้นตอนนี้เมื่อต้องการสร้างคลาสเพื่อประมวลผลแท็กแล้วมีความสามารถในการรับแอตทริบิวต์จากการใช้งานแท็กไ
ด้ด้วย การสร้างคลาสมีรูปแบบเช่นเดิมคือสร้างคลาสสืบทอดจาก TagSupport และมีเมธอด doStartTag
เพื่อรอบรับการเรียกใช้งานแท็ก แต่สิ่งที่เพิ่มขึ้นมาคือมีการสร้างเมธอดรูปแบบ setXxx เมื่อ Xxx

19. คือชื่อแอตทริบิวต์ที่มีตัวอักษรตัวแรกเป็นตัวใหญ่เหมือนเมธอดที่ทำงานกับจาวาบีน
นั่นเองดังนั้นรูปแบบคลาสที่สนับสนุนการกำหนดแอตทริบิวต์จึงมีโครงสร้างดังนี้
รูปแบบ
public void setXxx (String argument) {
…
}
เมื่อ
argument คืออาร์กิวเม็นต์ที่ได้รับจากการเรียกใช้งานแอตทริบิวต์ของแท็ก
ตัวอย่างซอร์สโค้ดต่อไปนี้เป็นการเพิ่มความสามารถของแท็กเปล่าเดิมให้มีความสามารถในการป้อนค่าแอตทริบิวต์ผ่านแท็ก
ดังนี้
1 package Tags;
2
3 import javax.servlet.jsp.*;
4 import javax.servlet.jsp.tagext.*;
5 import java.io.*;
6
7 public class TagSay2 extends TagSupport {
8 private String say1 = "Sawadee";
9 private String name = "Foo";
10
11 public int doStartTag() {
12 try {
13 JspWriter out = pageContext.getOut();
14 out.print(say1 + " K." + name);
15 } catch (IOException e) {
16 System.out.println(e);
17 }
18 return (SKIP_BODY);
19 }
20 public void setWho(String n) {
21 name = n;
22 }
23 }
พิจารณาจากซอร์สโค้ดด้านบนในไพล์ TagSay2.java ที่เป็นการสร้างคลาส TagSay2
โดยมีการกำหนดแอตทริบิวต์ในบรรทัดที่ 20 - 22 คือเมธอด setWho (ตัวอักษร w ตัวใหญ่) ที่สนับสนุนการทำงานของแอตทริบิวต์ชื่อ
who (ตัวอักษร w ตัวเล็ก) ที่นำค่าอาร์กิวเม็นต์มาให้ค่ากับตัวแปร name ของคลาสในบรรทัดที่ 21
ขั้นที่ 2 สร้างเอกสารข้อกำหนดแท็ก
สำหรับการสร้างเอกสารข้อกำหนดแท็กจำเป็นต้องเพิ่มอิลิเม็นต์ลงในเอกสารดังกล่าวย่อยลงจากอิลิเม็นต์ tag คือ attribute
ดังรูปแบบต่อไปนี้
รูปแบบ
<tag>
…
<attribute>
<name>attribute_name</name>
<required>true/false</required>
<rtxprvalue>true/false</rtxprvalue>

20. </attribute>
</tag>
เมื่อ
attribute_name คือชื่อแอตทริบิวต์
<required>…</required> คือข้อระบุความต้องการใช้งานแอตทริบิวต์
true เมื่อต้องกำหนดแอตทริบิวต์เมื่อใช้งานแท็ก
false เมื่อไม่จำเป็นต้องกำหนดแอตทริบิวต์เมื่อใช้งานแท็ก
<rtxprvalue>…</rtxprvalue> คือข้อระบุที่สามารถใช้งานแท็กเอ็กเพลสชั่นของเอกสาร JSP
ในการกำหนดค่าแอตทริบิวต์ได้
true เมื่ออนุญาตให้ใช้งานแท็กเอ็กเพลสชั่น
false เมื่อไม่อนุญาตให้ใช้งานแท็กเอ็กเพลสชั่น (ค่าปริยาย)
เพื่อให้สามารถใช้งานแอตทริบิวต์ได้ในเอกสารข้อกำหนดแท็กจึงมีการเพิ่มเติมส่วนอิลิเม็นต์ในรูปแบบดังนี้
1 <?xml version="1.0" encoding="UTF-8" ?>
2
3 <!DOCTYPE taglib
4 PUBLIC "-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.1//EN"
5 "http://java.sun.com/j2ee/dtd/web-jsptaglibrary_1_2.dtd">
6 <!-- a tag library descriptor -->
7
8 <taglib>
9 <tlibversion>1.0</tlibversion>
10 <jspversion>1.2</jspversion>
11 <shortname>ejp</shortname>
12 <uri></uri>
13 <info>A Tag Library from EJP</info>
14
15 <tag>
16 <name>say1</name>
17 <tagclass>Tags.TagSay1</tagclass>
18 <bodycontent>EMPTY</bodycontent>
19 <info>Tag to say</info>
20 </tag>
21
22 <tag>
23 <name>say2</name>
24 <tagclass>Tags.TagSay2</tagclass>
25 <bodycontent>EMPTY</bodycontent>
26 <info>Tag to say2</info>
27 <attribute>
28 <name>who</name>
29 <required>false</required>
30 <rtexprvalue>true</rtexprvalue>
31 </attribute>
32 </tag>
33
34 </taglib>
จากเอกสารข้อกำหนดแท็ก ejp-taglib.tld เดิมมีการเพิ่มเติมบรรทัดที่ 22-32 สังเกตจากตัวหนา ที่กำหนดชื่อแท็กเพิ่มเติมคือ
say2 ซึ่งเป็นแท็กเปล่าโดยเมื่อเรียกใช้งานแล้วเป็นการใช้งานคลาส TagSay2 ที่สร้างขึ้นมาใหม่ ที่สำคัญคือในบรรทัดที่ 27-31
ซึ่งเป็นการระบุการสร้างแอตทริบิวต์ให้กับแท็ก โดยตั้งชื่อแอตทริบิวต์ว่า who (สังเกตตัวอักษร w เป็นตัวเล็ก) ในบรรทัดที่ 28

21. และบรรทัดที่ 29 ในอิลิเม็นต์ required กำหนดด้วยรูปแบบ false นั่นคือสามารถใช้งานแอตทริบิวต์ who หรือไม่ใช้งานก็ได้
และในบรรทัดที่ 30 มีการกำหนดอิลิเม็นต์ rtexprvalue
ที่กำหนดให้สามารถใช้แท็กเอ็กเพลสชั่นในการกำหนดข้อมูลให้กับแอตทริบิวต์ได้
ข้อแนะนำ ในการตั้งชื่อแอตทริบิวต์ เมื่อตั้งในคลาสต้องกำหนดในเมธอดรูปแบบ setXxx
โดยใช้ชื่อแอตทริบิวต์ที่มีตัวอักษรตัวแรกเป็นตัวใหญ่ และในการสร้างเอกสารข้อกำหนดแท็ก
ให้ตั้งชื่อแอตทริบิวต์โดยใช้ตัวอักษรตัวแรกเป็นตัวเล็ก
ขั้นที่ 3 สร้างเอกสาร JSP เพื่อใช้งานแท็ก
ต่อไปเป็นการสร้างเอกสาร JSP เพื่อใช้งานแท็ก แน่นอนว่าต้องมีการอ้างถึงเอกสาร TLD ก่อนในตอนต้นของเอกสาร
1 <%@page contentType="text/html; charset=windows-874"%>
2 <html>
3 <%@taglib uri="ejp-taglib.tld" prefix="guy" %>
4 <head><title><guy:say2 /> </title></head>
5 <body>
6 <H1><guy:say2 who="Paralee Maneerat"/></H1>
7 <guy:say2 who='<%=request.getParameter("name")%>'/>
8 </body>
9 </html>
จากเอกสาร JSP ในไฟล์ TagSay2.jsp เป็นการเรียกใช้งานแท็กไลบรารี่จากเอกสาร ejp-taglib.tld โดยมีการตั้งชื่อต้นเป็นชื่อ
guy ที่มีการเพิ่มแท็กชื่อ say2 ลงไปในเอกสารดังกล่าวแล้ว จากนั้นในบรรทัดที่ 4, 6 และ 7 เป็นการอ้างถึงแท็ก say2 เมื่อบรรทัดที่ 4
เป็นการเรียกใช้แท็กโดยไม่มีการใส่ค่าแอตทริบิวต์ให้กับ who ซึ่งในที่นี้จะนำเอาค่าเริ่มต้นจากคลาส TagSay2 ไปใช้งานนั้นคือค่า Foo
ในขณะที่บรรทัดที่ 6 มีการกำหนดค่าแอตทริบิวต์ด้วยข้อความว่า Paralee Maneerat ส่วนในบรรทัดที่ 7
เป็นการกำหนดค่าให้กับแอตทิบิวต์ด้วยแท็กเอ็กเพลสชั่น ซึ่งก็คือการอ่านค่าพารามิเตอร์จากการใช้งานที่ชื่อ name
มาส่งให้กับแอตทิบิวต์ who
รูปแสดงการทำงานของเอกสาร TagSay2.jsp
จากรูปเป็นการนำค่าแอตทริบิวต์มาแสดงบนบราวเซอร์ มีสิ่งที่สังเกตอยู่อย่างหนึ่งคือในช่อง URL
ที่มีการกำหนดชื่อพารามิเตอร์ name ให้มีค่า Runrote Phonkam ซึ่งจากการทำงานของเอกสาร JSP
ข้อมูลดังกล่าวจะถูกนำไปแสดงในพื้นที่การแสดงผลของบราวเซอร์ ให้พิจารณาจากวงกลมเส้นปะของรูป

22. 9. การสร้างแท็กเปิดปิด
ในรายละเอียดต่อไปเป็นการสร้างแท็กที่มีการทำงานกับข้อมูลระหว่างแท็กเปิดและแท็กปิด โดยมีรูปแบบในการใช้งานดังนี้
รูปแบบ แท็กเปิดปิด
<tag_name attribute1="value1" attribute2="value2" …/></tag_name>
เมื่อ
tag_name คือชื่อแท็ก
attribute1, attribute2 คือชื่อแอตทริบิวต์
value1, value2 คือข้อมูลที่ต้องการส่งให้กับแอตทริบิวต์
ขั้นที่ 1 สร้างคลาสเพื่อประมวลผลแท็ก
สำหรับคลาสที่สนับสนุนการทำงานของแท็กแบบนี้จะต้องมีการทำงานเมื่อปรากฏแท็กเปิดและเมื่อปรากฏแท็กปิด
ดังนั้นต้องมีการสร้างเมธอดที่จัดการกับแท็กปิดคือ doEndTag และเช่นกันเนื่องจากในเอกสาร JSP
จะต้องมีข้อมูลต่อจากแท็กที่จะสร้างขึ้นดังนั้นในเมธอด doEndTag จึงจำเป็นต้องมีการคืนค่าด้วยตัวแปร EVAL_PAGE
เพื่อให้มีการทำงานกับเอกสาร JSP ในส่วนที่เหลือให้สมบูรณ์
รูปแบบซอร์สโค้ดเพื่อการสร้างคลาสสนับสนุนการทำงานของแท็กที่มีเนื้อข้อมูล
import javax.servlet.jsp.tagext.*;
class class_name extends TagSupport {
…
public int doStartTag() {
…
return (SKIP_BODY);
}
public ind doEndTag() {
…
return (EVAL_PAGE);
}
}
คลาส TagSay3 ต่อไปนี้เป็นการสร้างแท็กที่มีเนื้อข้อมูล ดังนั้นจะเห็นว่ามีการสร้างเมธอด doStartTag และ doEndTag
เข้ามาภายในคลาส
1 package Tags;
2
3 import javax.servlet.jsp.*;
4 import javax.servlet.jsp.tagext.*;
5 import java.io.*;
6
7 public class TagSay3 extends TagSupport {
8 private String say1 = "Sawadee";
9 private String say2 = "Bye Bye";
10 private String name = "Foo";
11
12 public int doStartTag() {

23. 13 try {
14 JspWriter out = pageContext.getOut();
15 out.print(say1 + " K." + name);
16 } catch (IOException e) {
17 System.out.println(e);
18 }
19 return (SKIP_BODY);
20 }
21 public void setWho(String n) {
22 name = n;
23 }
24 public int doEndTag() {
25 try {
26 JspWriter out = pageContext.getOut();
27 out.print(": and " + say2 + " K." + name);
28 } catch (IOException e) {
29 System.out.println(e);
30 }
31 return (EVAL_PAGE);
32 }
33 }
จากตัวอย่างซอร์สโค้ด เมื่อมีการสร้างแท็กเปิดเมธอด doStartTag จะทำงานโดยการพิมพ์คำว่า Sawadee K.
และตามด้วยข้อมูลในตัวแปร name ส่วนหากมีการสร้างแท็กปิดเมธอด doEndTag จะทำงานโดยมีการแสดงคำว่า Bye bye K.
และตามด้วยข้อมูลในตัวแปร name เช่นกัน
ขั้นที่ 2 สร้างเอกสารข้อกำหนดแท็ก
ในขั้นที่สองมีการปรับปรุงเอกสาร TLD ในไฟล์ ejp-taglib.tld
34 <?xml version="1.0" encoding="UTF-8" ?>
35
36 <!DOCTYPE taglib
37 PUBLIC "-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.1//EN"
38 "http://java.sun.com/j2ee/dtd/web-jsptaglibrary_1_2.dtd">
39 <!-- a tag library descriptor -->
40
41 <taglib>
42 <tlibversion>1.0</tlibversion>
43 <jspversion>1.2</jspversion>
44 <shortname>ejp</shortname>
45 <uri></uri>
46 <info>A Tag Library from EJP</info>
47
48 <tag>
49 <name>say1</name>
50 <tagclass>Tags.TagSay1</tagclass>
51 <bodycontent>EMPTY</bodycontent>
52 <info>Tag to say</info>
53 </tag>
54
55 <tag>
56 <name>say2</name>
57 <tagclass>Tags.TagSay2</tagclass>
58 <bodycontent>EMPTY</bodycontent>
59 <info>Tag to say2</info>
60 <attribute>
61 <name>who</name>
62 <required>false</required>
63 <rtexprvalue>true</rtexprvalue>
64 </attribute>
65 </tag>