Javacentrix com chap09-0

บทที ่ 9 จาวาบีนและแท็กไลบราร ี ่

มาจะกล่าวบทไปตอนนี้ผู้อ่านก็คงได้ทำความรู้จักวิธีการสร้าง

และการใช้งานเอกสาร JSP กันบ้างพอสมควรแล้ว จะเห็นว่าในการสร้างเอกสาร JSP

ทำให้ผู้สร้างเกิดความสะดวกที่ไม่จำเป็นต้องมาคอมไพล์ซอร์สโค้ดเหมือนกับการ

สร้างเซิรฟเล็ต

แต่ถึงแม้จะไม่ได้ทำเองแต่ก็มีผู้ช่วยที่ทำให้คือการอาศัยความสามารถของเว็บเซิร์

ฟเวอร์ที่จะมาทำหน้าที่คอมไพล์เอกสาร JSP

ให้เป็นเซิร์ฟเล็ตก่อนที่จะสามารถทำงานได้ต่อไป

แน่นอนว่าเอกสาร JSP ไม่ได้มีความสามารถเพียงเท่านี้

ภายในเอกสารผู้สร้างยังสามารถแทรกคำสั่งเพื่อให้สามารถติดต่อกับคลาสที่อยู่ภา

ยนอก หรือคลาสที่สร้างขึ้นมาเพื่อสนับสนุนการทำงานของ JSP

รูปแบบหนึ่งที่ดึงเอาหลักการทำงานของจาวาบีน (JavaBean)

มาใช้งานก็คือการทำงานร่วมกันระหว่างเอกสาร JSP และคลาสรูปแบบจาวาบีน

เพื่อใช้ในการจัดเก็บและการคำนวณในบางกรณีที่สามารถทำให้การใช้งานเอกสาร

JSP มีความยืดหยุ่นขึ้น

ยังไม่หมดครับนอกจากนี้แล้วผู้อ่านยังจะได้รู้จักกับสิ่งที่เรียกว่าแท็กไลบรารี่

ที่ช่วยให้เอกสาร JSP มีความยืดหยุ่นเข้าไปอีก

ก็คือการเรียกใช้งานคลาสจากภายนอกผ่านแท็กที่สามารถกำหนดชื่อขึ้นมาใช้งาน

ได้เอง

และทั้งจาวาบีนและแท็กไลบรารี่ก็คือเนื้อหาที่ผู้อ่านจะได้ทำความเข้าใจในบ

ทเรียกนี้นั่นเอง

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 {

…

}

- ในการจัดเก็บข้อมูลของจาวาบีนมีความหมายคือการจัดเก็บข้อมูลลงในแอตทริบิวต์ของคลาส

ซึ่งเมื้อมีการสร้างแอตทริบิวต์ของคลาสไม่ควรกำหนด 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; }

ในการกำหนดเมธอดในการอ่านค่า ไม่จำเป็นที่จะต้องใช้สำหรับการอ่านค่าเพื่อส่งค่าจากแอตทริบิวต์ไปหาผู้รับเท่านั้น

ยังสามารถสร้างเมธอดโดยไม่จำเป็นต้องสัมพันธ์กับชื่อแอตทริบิวต์เลย

แต่เป็นเมธอดที่ส่งค่าคือหากมีการประมวลผลก็ได้แต่มีการตั้งชื่อเมธอดตามรูปแบบ 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

ได้ดังนี้

การติดตั้งคลาสจาวาบีน

ในการติดตั้งคลาสที่สร้างสำหรับทำงานเป็นจาวาบีนนี้ ผู้สร้างต้องติดตั้งคลาสในตำแหน่งเดียวกันกับการติดตั้งเซิร์ฟเล็ต

เนื่องจากเอกสาร JSP จะพิจารณาจาวาบีนในตำแหน่งเดียวกันกับเซิร์ฟเล็ต ดังนั้นจากคลาส Person

ที่มีการสร้างให้บรรจุอยู่ในแพ็กเกจชื่อ Beans ตามคำสั่งในบรรทัดที่ 1 ดังนั้นคลาสที่ได้รับจากการคอมไพล์คือ Person

ควรติดตั้งอยู่ในเว็บเซิร์ฟเวอร์ที่ได้ทำการทดสอบ ในเส้นทางดังนี ้

C:\Program Files\Apache Tomcat 4.0\webapps\ejp\WEB-INF\classes\Beans\Person.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 คือชื่อจาวาบีน

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 ตำแหน่งดังกล่าวก็จะแสดงข้อมูลตามที่ได้รับมาจากแท็ก

รูปแบบ

<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");

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 มีการใช้สัญลักษณ์ " สามารถเปลี่ยนการใช้งาน

สัญลักษณ์ " ที่ใช้งานกับแอตทริบิวต์ 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

ซึ่งจะช่วยให้เกิดความสะดวกในการนำพาเอาข้อมูลพารามิเตอร์ไม่ว่ากรณีใดๆ ส่งให้กับจาวาบีน

โดยผู้ใช้ไม่จำเป็นต้องอ้างด้วยแท็กเอ็กเพลสชั่นเหมือนในตัวอย่างที่กล่าวมา

รูปแบบ

<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 เพื่ออ้างถึงและอ่านข้อมูลเพื่อส่งให้กับจาวาบีนต่อไป

รูปแสดงฟอร์มที่ได้จากการทำงานของเอกสาร 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 ที่อ้างถึงฟิลด์ที่ไม่ได้กรอกข้อมูลจะไม่มีการทำงานใดๆเกิดขึ้น

จากตัวอย่างที่แสดงให้เห็นเป็นการสร้างฟอร์มที่บรรจุฟิลด์ไม่กี่จำนวน แต่หากมีการสร้างฟอร์มที่มีจำนวนฟิลด์ค่อนข้างมาก

เพื่อให้เกิดความสะดวกมากยิ่งขึ้น หากชื่อฟอร์มที่ตั้งขึ้นตรงกับชื่อที่ใช้ในการอ้างถึงของแอตทริบิวต์ 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

มีข้อกำหนดพิเศษที่ช่วยทำให้ชื่อจาวาบีนสามารถอ้างเพื่อใช้งานได้มากกว่าภายในเอกสารเดียวกันด้วยแอตทริบิวต์ 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 ที่มีการเรียกใช้งานแท็กที่กำหนดไว้เพื่อดึงเอาคลาสที่กำหนดไว้มาทำงานและประมวลผลตามความต้องการของผู้สร้าง

ซึ่งแท็กไลบรารี่จะคล้ายกันกับจาวาบีน แต่ต่างที่จาวาบีนต้องใช้แท็กที่กำหนดไว้ก่อนหนา้นี้แล้วคือ 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() {

…

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 Files\Apache Tomcat 4.0\webapps\ejp\WEB-INF\classes\Tags\TagSay.class

ขั้นที่ 2 สร้างเอกสารข้อกำหนดแท็ก

ในขั้นตอนที่สองนี้เป็นการกำหนดชื่อแท็ก เพื่อให้ส่งการทำงานไปยังคลาสที่สร้างไว้ในขั้นตอนแรก

ในการกำหนดชื่อคลาสมีการสร้างไฟล์ที่ใช้กำหนดอธิบายส่วนประกอบของแท็ก เช่น ชื่อ การนำไปใช้งาน การอ้างอิงคลาส เป็นต้น

ไฟล์ดังกล่าวเป็นไฟล์ที่มีนามสกุล .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

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  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 Files\Apache Tomcat 4.0\webapps\ejp\ejp-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 สามารถใช้งานแท็กได้จาก

หลายไฟล์ข้อกำหนด ดังนั้นจึงต้องใช้ชื่อต้นเพื่อบอกว่าใช้จากเอกสารใด

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" …/>

เมื่อ


attribute1, attribute2 คือชื่อแอตทริบิวต์

value1, value2 คือข้อมูลที่ต้องการส่งให้กับแอตทริบิวต์


สำหรับในขั้นตอนนี้เมื่อต้องการสร้างคลาสเพื่อประมวลผลแท็กแล้วมีความสามารถในการรับแอตทริบิวต์จากการใช้งานแท็กไ

ด้ด้วย การสร้างคลาสมีรูปแบบเช่นเดิมคือสร้างคลาสสืบทอดจาก TagSupport และมีเมธอด doStartTag

เพื่อรอบรับการเรียกใช้งานแท็ก แต่สิ่งที่เพิ่มขึ้นมาคือมีการสร้างเมธอดรูปแบบ setXxx เมื่อ Xxx

คือชื่อแอตทริบิวต์ที่มีตัวอักษรตัวแรกเป็นตัวใหญ่เหมือนเมธอดที่ทำงานกับจาวาบีน

นั่นเองดังนั้นรูปแบบคลาสที่สนับสนุนการกำหนดแอตทริบิวต์จึงมีโครงสร้างดังนี ้

รูปแบบ

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


สำหรับการสร้างเอกสารข้อกำหนดแท็กจำเป็นต้องเพิ่มอิลิเม็นต์ลงในเอกสารดังกล่าวย่อยลงจากอิลิเม็นต์ tag คือ attribute

ดังรูปแบบต่อไปนี ้

รูปแบบ

<tag>

…

<attribute>

<name>attribute_name</name>

<required>true/false</required>

<rtxprvalue>true/false</rtxprvalue>

</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  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

และบรรทัดที่ 29 ในอิลิเม็นต์ required กำหนดด้วยรูปแบบ false นั่นคือสามารถใช้งานแอตทริบิวต์ who หรือไม่ใช้งานก็ได้

และในบรรทัดที่ 30 มีการกำหนดอิลิเม็นต์ rtexprvalue

ที่กำหนดให้สามารถใช้แท็กเอ็กเพลสชั่นในการกำหนดข้อมูลให้กับแอตทริบิวต์ได้

ข้อแนะนำ ในการตั้งชื่อแอตทริบิวต์ เมื่อตั้งในคลาสต้องกำหนดในเมธอดรูปแบบ setXxx

โดยใช้ชื่อแอตทริบิวต์ที่มีตัวอักษรตัวแรกเป็นตัวใหญ่ และในการสร้างเอกสารข้อกำหนดแท็ก

ให้ตั้งชื่อแอตทริบิวต์โดยใช้ตัวอักษรตัวแรกเป็นตัวเล็ก


ต่อไปเป็นการสร้างเอกสาร 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

ข้อมูลดังกล่าวจะถูกนำไปแสดงในพื้นที่การแสดงผลของบราวเซอร์ ให้พิจารณาจากวงกลมเส้นปะของรูป

9. การสร้างแท็กเปิดปิด

ในรายละเอียดต่อไปเป็นการสร้างแท็กที่มีการทำงานกับข้อมูลระหว่างแท็กเปิดและแท็กปิด โดยมีรูปแบบในการใช้งานดังนี ้

รูปแบบ แท็กเปิดปิด

<tag_name attribute1="value1" attribute2="value2" …/></tag_name>

เมื่อ





สำหรับคลาสที่สนับสนุนการทำงานของแท็กแบบนี้จะต้องมีการทำงานเมื่อปรากฏแท็กเปิดและเมื่อปรากฏแท็กปิด

ดังนั้นต้องมีการสร้างเมธอดที่จัดการกับแท็กปิดคือ 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() {

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 เช่นกัน


ในขั้นที่สองมีการปรับปรุงเอกสาร 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  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>

66 67 <tag> 68 <name>say3</name> 69 <tagclass>Tags.TagSay3</tagclass> 70 <bodycontent>EMPTY</bodycontent> 71 <info>Tag to say3</info> 72 <attribute> 73 <name>who</name> 74 <required>false</required> 75 </attribute> 76 </tag> 77 78 </taglib>

จากเอกสารข้องต้นโดยมีการแท็กใหม่ชื่อ say3 ในบรรทัดที่ 76-85 เพื่อรองรับการทำงานของคลาส TagSay3


ขั้นตอนต่อไปเป็นการทดสอบการทำงาน โดยการสร้างเอกสารใหม่ที่ชื่อ TagSay3.jsp โดยมีคำสั่งดังนี้ 1 <%@page contentType="text/html; charset=windows-874"%> 2 <html> 3 <%@taglib uri="ejp-taglib.tld" prefix="gang" %> 4 <head><title>Show Tag Library</title></head> 5 <body> 6 <gang:say3 who="Servlet & JSP"></gang:say3> 7 </body> 8 </html>

เมื่อบรรทัดที่ 3 มีการใช้งานแท็กโดยมีการตั้งชื่อต้นว่า gang และในบรรทัดที่ 6 มีการใช้งานแท็ก

จะเห็นว่ามีการสร้างทั้งแท็กเปิดและแท็กปิด ซึ่งจะปรากฏทั้งข้อมูล Sawadee และ Bye bye จากการทำงานในเมธอด doStartTag และ

doEndTag ในคลาส TagSay3 ที่สร้างไว้ในตอนต้น

รูปแสดงเอกสารจากการทำงานของ TagSay3.jsp

10. การสร้างแท็กบรรจุเนื้อข้อมูล

ตอนนี้เมื่อมีแท็กเปิดและแท็กปิดแล้ว

สิ่งที่จะทำต่อไปเป็นการสร้างแท็กที่สามารถบรรจุเนื้อข้อมูลระหว่างแท็กเปิดและแท็กปิดได้

โดยขึ้นอยู่กับการบรรจุเนื้อข้อมูลดังกล่าวว่าผู้สร้างต้องการบรรจุเนื้อข้อความปกติ หรือแท็กที่สามารถประมวลผล JSP อื่นๆ

ลองมาดูรูปแบบการสร้างแท็กที่มีเนื้อข้อมูลกันดูก่อนว่าเป็นอย่างไร

รูปแบบ แท็กที่มีเนื้อข้อมูล

<tag_name attribute1="value1" attribute2="value2" …>body_content</tag_name>

เมื่อ

body_content คือเนื้อข้อมูลระหว่างแท็ก





การสร้างคลาสที่สามารถรองรับการใส่เนื้อข้อมูลระหว่างแท็กเปิดและแท็กปิด

มีการปรับปรุงเพียงจุดเดียวคือการคืนค่าของเมธอด doStartTag จากแท็กที่ไม่มีเนื้อข้อมูลที่ผ่านๆมาเปลี่ยนการคืนค่าจากตัวแปร

SKIP_BODY ไปเป็น EVAL_BODY_INCLUDE เพื่อให้การทำงานมีการพิจารณาที่เนื้อข้อมูลระหว่างแท็กด้วย 1 package Tags; 2 3 import javax.servlet.jsp.*; 4 import javax.servlet.jsp.tagext.*; 5 import java.io.*; 6 import java.lang.*; 7 import java.util.*; 8 import Phone.BeanPhone; 9 10 public class TagPhoneBook extends TagSupport { 11 private Vector PhoneBook = new Vector(); 12 int count = 0; String debug = ""; 13 public int doStartTag() { 14 try { 15 JspWriter out = pageContext.getOut(); 16 out.print("-- �� --<BR>"); 17 } catch (IOException e) { 18 System.out.println(e); 19 } 20 return (EVAL_BODY_INCLUDE); 21 } 22 23 public void setAdd(String n) { 24 StringTokenizer sb = new StringTokenizer(n); 25 BeanPhone p; 26 String name, phone; 27 while (sb.hasMoreTokens()) { 28 name = sb.nextToken(); 29 phone = sb.nextToken(); 30 count += 2; 31 debug = debug + ": " + name + ": " + phone; 32 p = new BeanPhone(); 33 p.setPhoneName(name); p.setPhoneNumber(phone); 34 PhoneBook.addElement(p); 35 } 36 } 37 38 public int doEndTag() { 39 try { 40 JspWriter out = pageContext.getOut(); 41 BeanPhone p; 42 for(int i=0; i<PhoneBook.size(); i++) { 43 p = (BeanPhone)PhoneBook.elementAt(i); 44 out.print("<BR>" + p.getPhoneName() + " : " + p.getPhoneNumber());

45 } 46 out.print("<BR>-- �� --<BR>"); 47 } catch (IOException e) { 48 System.out.println(e); 49 } 50 return (EVAL_PAGE); 51 } 52 }

จากซอร์สโค้ดคือไฟล์ TagPhoneBook.java จากบรรทัดที่ 8

มีการอ้างการใช้งานคลาสที่เคยใช้ในจาวาบีนแล้วในเนื้อหาของจาวาบีนคือคลาส BeanPhone บรรทัดที่ 11 มีการสร้างตัวแปร

PhoneBook เพื่อเก็บอินสแตนซ์จากคลาส BeanPhone ในแบบ Vector เพื่อให้สามารถเก็บรายชื่อเป็นรายการได้ และมีเมธอดที่ชื่อ

setAdd เพื่อแยกข้อมูลแอตทริบิวต์ส่วนชื่อและส่วนเบอร์โทร ไปบรรจุในตัวแปร PhoneBook

ในเมธอด doStartTag ทำงานเพียงแค่การแสดงข้อความ เริ่มรายการ และมีการคืนค่าด้วยตัวแปร EVAL_BODY_INCLUDE เนื่องจากแท็กที่สร้างขึ้นมีเนื้อข้อมูลอยู่ระหว่างแท็ก ส่วนในเมธอด doEndTag แสดงรายชื่อในตัวแปร PhoneBook

ด้วยการใช้ลูปค่อยๆแสดงที่ละรายการ และแสงดข้อความ จบรายการ จากนั้นคืนค่าด้วยตัวแปร EVAL_PAGE

เพื่อดำเนินการส่วนต่อไปในเอกสาร


ในการสร้างเอกสารข้อกำหนดแท็ก มีสิ่งที่เปลี่ยนแปลงจากเดิมคืออิลิเม็นต์ bodycontent เปลี่ยนจากเดิมคือ EMPTY ไปเป็น

JSP เพื่อให้สามารถดำเนินเนื้อข้อมูลระหว่างแท็กได้ทั้งข้อความปกติ และแท็กคำสั่งต่างๆของ JSP ได้

แต่หากผู้สร้างไม่ต้องการให้มีการประมวลผลในเนื้อข้อความระหว่างแท็กได้ ก็ให้ระบุเป็น TAGDEPENDENT

เพื่อให้ใช้งานเพียงบรรจุข้อความระหว่างแท็กเท่านั้น 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  7 8 <taglib> 9 <tlibversion>1.0</tlibversion> 10 <jspversion>1.2</jspversion> 11 <shortname>Books</shortname> 12 <info>A Phone Book</info> 13 <tag> 14 <name>phonebook1</name> 15 <tagclass>Tags.TagPhoneBook</tagclass> 16 <bodycontent>JSP</bodycontent> 17 <info>Tag of Phone Book</info> 18 <attribute> 19 <name>add</name> 20 <required>true</required> 21 <rtexprvalue>true</rtexprvalue> 22 </attribute> 23 </tag> 24 <tag> 25 <name>phonebook2</name> 26 <tagclass>Tags.TagPhoneBook</tagclass> 27 <bodycontent>TAGDEPENDENT</bodycontent> 28 <info>Tag of Phone Book</info> 29 <attribute> 30 <name>add</name> 31 <required>true</required> 32 <rtexprvalue>false</rtexprvalue>

33 </attribute> 34 </tag> 35 </taglib>

จากตัวอย่างเอกสาร TLD ในไฟล์ phone-taglib.tld ที่มีการสร้างแท็กสองแท็กคือ phonebook1 ที่กำหนดอิลิเม็นต์

bodycontent เป็น JSP ส่วนแท็กที่สองคือ phonebook2 ที่กำหนดอิลิเม็นต์ bodycontent เป็น TAGDEPENDENT


1 <%@page contentType="text/html; charset=windows-874"%> 2 <%@page import="java.util.*, java.text.*"%> 3 <html> 4 <%@taglib uri="phone-taglib.tld" prefix="myPhoneBook" %> 5 <head><title>JSP Phone Book</title></head> 6 <body> 7 <myPhoneBook:phonebook1 add="Mr.A 123 Mr.B 456 Mr.C 789 Mr.D 111"> 8 �� 9 <%=DateFormat.getDateTimeInstance().format(new Date())%> 10 </myPhoneBook:phonebook1> 11 <myPhoneBook:phonebook2 add="Mr.A 123 Mr.B 456 Mr.C 789 Mr.D 111"> 12 �� 13 <%=DateFormat.getDateTimeInstance().format(new Date())%> 14 </myPhoneBook:phonebook2> 15 </body> 16 </html>

จากตัวอย่างเอกสารในไฟล์ชื่อ TagPhoneBook.jsp มีการอ้างถึงไฟล์ phone-taglib.tld เพื่อใช้งานแท็กที่ได้สร้างขึ้น

โดยตั้งชื่อต้นว่า myPhoneBook ในบรรทัดที่ 7 - 10 เป็นการใช้งานแท็กชื่อ phonebook1

ให้สังเกตว่ามีการบรรจุแท็กเอ็กเพลสชั่นในบรรทัดที่ 9 เพื่อแสดงวันที่และเวลา ส่วนในบรรทัดที่ 11-14 เป็นการใช้งานแท็กชื่อ

phonebook2 โดยมีการบรรจุแท็กเอ็กเพลสชั่นในบรรทัดที่ 13

รูปแสดงการทำงานของเอกสาร TagPhoneBook.jsp

จากผลลัพธ์ของการทำงานของแท็ก phonebook1 จะเห็นตัวเลขวันที่และเวลาปรากฏอยู่ ในขณะที่แท็ก phonebook2 ไม่มี

ซึ่งสืบเนื่องจากการสร้างเอกสาร TLD ในการระบุอิลิเม็นต์ bodycontent

11. การสร้างแท็กที่มีการทำงานซ้ำ

การทำงานของแท็กที่กล่าวมาจะทำงานเพียงครั้งเดียว หากต้องการทำงานหลายครั้งต้องใส่แท็กลงในเอกสาร JSP

ตามจำนวนที่ต้องการให้ทำงานทำให้เกิดความไม่สะดวกในการทำงาน

สำหรับการสร้างแท็กไลบรารีแ่ล้วมีวิธีในการสร้างแท็กที่สามารถทำงานซ้ำไปซ้ำมาได้ตามต้องการ


แท็กที่มีการทำงานซ้ำคือการสร้างแท็กที่สามารถทำงานอ่านข้อมูลในเนื้อความมาทำงานได้

จากความสามารถนี้จำเป็นต้องสร้างคลาสที่สืบทอดมาจากคลาส BodyTagSupport ที่มีการเพิ่มความสามารถดังกล่าว

นั่นคือสามารถสร้างเมธอด doAfterBody ที่จะทำงานเมื่อมีการอ่านข้อมูลเนื้อความ โดยในเมธอดนี้หากมีการคืนค่าด้วยตัวแปร

SKIP_BODY ก็จะสิ้นสุดการทำงาน แต่หากมีการคืนค่าเป็น EVAL_BODY_TAG เนื้อความจะถูกย้อนไปทำงานอีกครั้งหนึ่ง

ลองพิจารณาตัวอย่างคลาสต่อไปนี ้1 package Tags; 2 3 import javax.servlet.jsp.*; 4 import javax.servlet.jsp.tagext.*; 5 import java.io.*; 6 import java.lang.*; 7 import java.util.*; 8

9 public class TagRepeat extends BodyTagSupport { 10 private int number; 11 private int loop; 12 private int counter; 13 14 public void setNumber(String n) { 15 number = Integer.parseInt(n); 16 } 17 18 public void setLoop(String l) { 19 loop = Integer.parseInt(l); 20 counter = loop; 21 } 22 23 public int doStartTag() { 24 try { 25 JspWriter out = pageContext.getOut(); 26 out.print("-- �� " + number + " --<BR>"); 27 } catch (IOException e) { 28 System.out.println(e); 29 } 30 return (SKIP_PAGE); // �� SKIP_PAGE

�� body 31 } 32 33 public int doAfterBody() { 34 int c = loop - counter + 1; // �� 35 if (counter > 0) { 36 BodyContent body = getBodyContent(); 37 try { 38 JspWriter out = body.getEnclosingWriter(); 39 out.print(body.getString() + number + " x " + c + " = " + (number*c) + "<BR>"); 40 } catch (IOException e) { 41 System.out.println(e); 42 } 43 counter--; // �� 44 return (EVAL_BODY_TAG); 45 } else 46 return (SKIP_BODY); 47 } 48 49 public int doEndTag() { 50 try { 51 JspWriter out = pageContext.getOut(); 52 out.print("<BR>-- �� --<BR>"); 53 } catch (IOException e) { 54 System.out.println(e); 55 } 56 return (EVAL_PAGE); 57 } 58 }

จากซอร์สโค้ดคือไฟล์TagRepeat ทำงานโดยการพิมพ์สูตรคูณ โดยมีการกำหนดเมธอดเพื่อกำหนดแอตทริบิวต์สองตัว เมธอด

setNumber คือการกำหนดแม่สูตรคูณ เมธอด setLoop เป็นการกำหนดจำนวนการแสดงรายการสูตรคูณโดยเริ่มตั้งแต่การคูณด้วยค่า 1

นอกจากนั้นมีเมธอดทำงานสำหรับแท็กเปิดคือ doStartTag และสำหรับแท็กปิดคือ doEndTag

เพื่อพิมพ์ข้อความแสดงการเริ่มต้นและการสิ้นสูตรของตารางสูตรคูณ ส่วนเมธอด doAfterBody

จะทำงานพิมพ์สูตรคูณที่ละรายการโดยเริ่มต้นตั้งแต่การคูณ 1 และเลือกการคืนค่าระหว่าง SKIP_BODY กับ EVAL_BODY_TAG

ที่จะเลือกว่าหากไม่ครบจำนวนลูปที่ต้องการจากตัวแปร counter ที่มากกว่า 0 ก็จะคือค่า EVAL_BODY_TAG

เพื่อเป็นการให้วนกลับมาทำงานใหม่ และมีการลดค่าตัวแปร counter ไปเรื่อยๆจนกว่าจะมีค่าเท่ากับ 0 ก็จะคืนค่า SKIP_BODY

เป็นอันสิ้นสุดการทำงาน


การสร้างเอกสาร TLD ยังคงเป็นการสร้างปกติเหมือนที่เคยกล่าวรายละเอียดมา 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  7 8 <taglib> 9 <tlibversion>1.0</tlibversion> 10 <jspversion>1.2</jspversion> 11 <shortname>RepeatTag</shortname> 12 <info>Repeat Body Tag</info> 13 <tag> 14 <name>repeat</name> 15 <tagclass>Tags.TagRepeat</tagclass> 16 <bodycontent>JSP</bodycontent> 17 <info>Tag of Repeat</info> 18 <attribute> 19 <name>number</name> 20 <required>true</required> 21 </attribute> 22 <attribute> 23 <name>loop</name> 24 <required>true</required> 25 </attribute> 26 </tag> 27 </taglib>

จากเอกสารในไฟล์ repeat-taglib.tld ที่มีการสร้างแท็กชื่อ repeat โดยมีการรับค่าแอตทริบิวต์สองตัวคือ number และ loop

ตามลำดับ


มาถึงขั้นตอนสุดท้ายซึ่งเป็นการทดสอบการทำงานของคลาสและเอกสาร TLD ที่สร้างมาจากสองขั้นตอนแรก ด้วยเอกสาร

JSP ดังนี้ 1 <%@page contentType="text/html; charset=windows-874"%> 2 <%@taglib uri="repeat-taglib.tld" prefix="fomular" %> 3 <html> 4 <head><title>JSP Repeat</title></head> 5 <body> 6 <fomular:repeat number="12" loop="12" > </fomular:repeat> 7 <I><fomular:repeat number="5" loop="5"> </fomular:repeat></I> 8 <B><fomular:repeat number="7" loop="12"> </fomular:repeat></B> 9 </body> 10 </html>

เอกสาร JSP ข้างต้นคือ TagRepeat.jsp เป็นการใช้งานแท็ก repeat จำนวน 3 ครั้ง

ในแต่ละครั้งจะเป็นการพิมพ์สูตรคุณตามค่าแอตทริบิวต์ที่แตกต่างกัน โดยแท็กแรกเป็นการพิมพ์สูตรคูณแม่ 12 จำนวน 12 รายการ

แท็กที่สองเป็นการพิมพ์สูตรคูณแม่ 5 จำนวน 5 รายการ และแท็กสุดท้ายเป็นการพิมพ์สูตรคูณแม่ 7 จำนวน 12 รายการ

รูปแสดงการทำงานของเอกสาร TagRepeat.jsp

การสร้างแท็กสามารถวางแท็กซ้อนกันได้ และแท็กชั้นในสามารถอ้างถึงคลาสที่ทำงานในแท็กชั้นนอกได้

ด้วยการเรียกใช้งานเมธอด findAncestorWithClass โดยมีรูปแบบดังนี ้

รูปแบบการอ้างคลาสชั้นนอกจากแท็กชั้นใน

Outer_Tag_Class parent = (Outer_Tag_Class) findAncestorWithClass(this, Outer_Tag_Class.class)

เมื่อ

Outer_Tag_Class คือชื่อคลาสของแท็กชั้นนอก

ตัวอย่างการใช้งานแท็กซ้อนที่อ้างถึงกันดูได้จากบทที่ 11

ซึ้งเป็นการพัฒนาระบบขายสินค้าออนไลน์ที่เกี่ยวข้องกับระบบฐานข้อมูล

หลังจากศึกษาการใช้งานจาวาบีน และการสร้างแท็กไลบรารี่เพื่อใช้งานในเอกสาร JSP แล้ว หากผู้อ่านลองสำรวจบนอินเตอร์เน็ต

เช่น http://www.jspin.com ดูจะเห็นว่ามีจาวาบีน และแท็กไลบรารี่ให้ดาวน์โหลดเพื่อใช้งานฟรี หรือจำหน่ายในทางการค้า

หากผู้อ่านได้ทดลองใช้งานจะเห็นว่าสามารถนำมาสร้างเอกสารเพื่อเผยแพร่บนอินเตอร์เน็ตได้อย่างดีทีเดียว

ในบทต่อไปเราจะมาสร้างเอกสาร JSP ในรูปแบบทีเ่กี่ยวกับการจัดเก็บข้อมูลดูกันบ้าง ด้วยการทำงานกับระบบฐานข้อมูล

Documents

Javacentrix com chap09-0