JSP คืออะไร JSP ย่อมาจาก Java Server Pages เทคโนโลยีที่คิดค้นโดยบริษัท Sun Microsystems (ผู้ผลิตคอมพิวเตอร์ซันและผู้พัฒนาจาวา) โดยพัฒนาบนพื้นฐานของภาษาจาวาเพื่อเพิ่มประสิทธิภาพ ให้หน้าเว็บเพจมีความยืดหยุ่นสูงขึ้น โครงสร้างของ JSP นั้นเป็นลักษณะของแท็ก (tag) ชนิดพิเศษที่แทรกเข้าไปในเอกสาร HTML และเปลี่ยนนามสกุลของเอกสารเป็น . JSP แทนที่จะเป็น .HTMหรือ .HTML โดยแท็กเหล่านี้เว็บบราวเซอร์จะไม่สามารถตีความหมายได้ จะต้องนำไปประมวลผลก่อนที่เว็บเซิร์ฟเวอร์เท่านั้น (หรือที่เราเรียกว่าการทำงานแบบ Server Side) แล้วนำผลลัพธ์ทั้งหมดส่งกลับมายังเว็บบราวเซอร์ในลักษณะของเอกสาร HTML ซึ่งเว็บบราวเซอร์สามารถตีความหมายและนำมาแสดงผลได้ การทำงานโดยรวมของ JSP จะเริ่มจากบราวเซอร์ร้องขอ (HTTP Request) เอกสารที่มีนามสกุลเป็น JSP ไปยังเว็บเซิร์ฟเวอร์ผ่านทางโปรโตคอล HTTPเว็บเซิร์ฟเวอร์ก็จะนำเอกสาร JSP ที่ได้รับมานั้นส่งต่อไปให้ JSP Engine (JSPEngine คือ แอพพลิเคชันที่ถูกโหลดสู่หน่วยความจำและทำงานอยู่บนเว็บเซร์ฟเวอร์ หน้าที่หลักคือแปลความหมายและประมวลผลเอกสาร JSP) จากนั้น JSPEngine ก็จะประมวลผล และส่งผลลัพธ์กลับมายังเว็บเซิร์ฟเวอร์ แล้วเว็บเซิร์ฟเวอร์ก็จะส่งผลลัพธ์กลบมายังบราวเซอร์ (HTTP Reponse) อีกที ในลักษณะของเอกสาร HTML บราวเซอร์ก็จะสามารถแสดงผลได้
1.2 JSP หรือ Servlet
Servlet เป็นเทคโนโลยีที่คิดค้นก่อน JSP และนำเอาภาษาจาวามาใช้เป็นพื้นฐานบนเว็บเช่นเดียวกัน การทำงานของทั้งสองก็คล้ายกันทุกอย่าง แต่ JSPจะมีขั้นตอนที่เพิ่มขึ้นมาคือ การแปลงเอกสาร JSP ให้เป็น Servlet ก่อน สรุปก็คือสุดท้ายเอกสาร JSP จะต้องถูกแปลงเป็น Servlet นั่นเอง สำหรับผู้ที่เคยใช้Servlet มาบ้างจะรู้ดีว่าการแสดงผลของ Servlet จะค่อนข้างยุ่งยากเพราะไม่สามารถใส่แท็ก HTML แทรกเข้าไปได้ ต้องพิมพ์แท็ก HTML ออกมาเอง โดยใช้คำสั่ง out.print() แต่ถ้าเป็น JSP แล้วเราสามารถนำแท็ก HTML มารวมกับแท็ก JSP ได้เลย ลองเปรียบเทียบเอกสาร JSP และ Servlet ทั้งสองตัวนี้ServletJSP ตัวอย่างโค้ดทั้ง Servlet และ JSP จะให้ผลเหมือนกันคือพิมพ์คำว่า “Hello World” ออกมาที่บราวเซอร์ แต่จะเห็นว่าการใช้ JSP ทำให้การจัดหน้าตาของเอกสาร HTML ทำได้สะดวกขึ้นเพราะสามารถสร้างเอกสาร HTML จากเครื่องมือต่าง ๆ ที่มีประสิทธิภาพต่าง ๆ เช่น Macromedia Dreamweaver หรือ MicrosoftFrontPage ก่อน แล้วค่อยนำแท็ก JSP เข้าไปแทรกภายหลัง ทำให้การแสดงข้อมูลเพื่อนำเสนอจะทำได้อย่างมีประสิทธิภาพมากกว่า
1.3 ทำไมต้องใช้ JSPข้อดีของ JSP คือ
1. Write Once Run Anywhere JSP มีพื้นฐานมาจากภาษาจาวา เมื่อเอ่ยถึงภาษาวาจาข้อดีประการหนึ่งที่มีตามมาด้วยคือการทำงานได้ในหลายระบบปฏิบัติการไม่ว่าจะเห็น Mac OS, Linux และ Windows เพราะฉะนั้นผู้พัฒนาโปรแกรมไม่ต้องสนใจเลยว่าโปรแกรมที่พัฒนาขึ้นมานั้นจะมีผลกระทบอะไรบ้างเมื่อมีการย้ายไปทำงานบนระบบปฏิบัติการอื่น
2. Component Reusable ด้วยความสามารถในการนำจาวาบีน (Java Bean) มาใช้ ซึ่งมีลักษณะเป็นคอมโพเน็นต์ ทำให้คอมโพเน็นต์เหล่านี้สามารถนำกลับมาใช้ได้ใหม่และใช้ร่วมกันระหว่างผู้พัฒนาเว็บไซต์ทำให้การพัฒนาทำได้เร็วขึ้น เช่น หากเราสร้างคอมโพเน็นต์ ที่ทำการเชื่อมต่อกับฐานข้อมูลไว้ เมื่อมีการสร้างเอกสาร JSP ใหม่ขึ้นมาและต้องการเชื่อมต่อกับฐานข้อมูล ก็จะทำได้โดยการเรียกใช้คอมโพเน็นต์ที่ได้สร้างไว้แล้ว
3. JAVA Extension เมื่อ JSP พัฒนาบนพื้นฐานของจาวา ซึงมีคุณสมบัติหลายอย่างไม่ว่าจะเป็น การโปรแกรมเชิงวัตถุ(Object Oriented Programming) ,การทำงานกับ Thread (Multithreading), การจัดการกับข้อผิดพลาด (ErrorHandling) ทำให้คุณสมบัติเหล่านี้มีใน JSP ด้วย
4. Separation of Dynamic and Static Content การแยกจากกันระหว่างส่วนที่เป็นไดนามิก เช่น ข้อมูล กับส่วนที่เป็นสแตติก เช่น แท็ก HTML ต่าง ๆ ทำให้การดูแลและพัฒนาเว็บไซต์ง่ายขึ้นNote : JAVA Bean คือ คอมโพเน็นท์ภาษาจาวาที่สามารถนำกลับมาใช้ใหม่ได้หากเคยใช้ Delphi หรือ Visual Basic มาก่อน ก็ให้มองว่าบีนก็คล้ายกับคอมโพเนนต์ต่างๆ ที่มีในโปรแกรมเหล่านี้ ยกตัวอย่างเช่น button, scroll bar, list box,dialog box ฯลฯ การสร้างคอมโพเนนต์บีนนั้นจะใช้ชุด Bean Development Kit(BDK)
1.4 เปรียบเทียบกับ ASP
เมื่อมองความสามารถของการทำงานโดยรวม JSP จะคล้ายกับ ASP มากเช่น รูปแบบของการโปรแกรม เพราะสามารถแทรกแท็กเข้าไปในเอกสารHTML ได้ อย่างไรก็ตามJSP พัฒนามาจากจาวาซึ่งมีข้อดีเหนือกว่าภาษา VisualBasic ในด้านการจัดการข้อผิดพลาดและการทำงานในลักษณะ MultiThreadingรวมทั้ง JSP สามารถทำงานได้ทุกระบบปฏิบัติการ ถึงแม้ว่ามีโปรแกรมบางตัวนอกเหนือจาก llS ที่สามารถทำงานกับ ASP ได้บนระบบปฏิบัติการ UNIX แต่โดยพื้นฐานแล้ว ASP ต้องใช้ฟังก์ชันจาก Active X แต่ระบบปฏิบัติการ UNIXยังไม่รองรับ Active X จึงเหมือนว่า ASP สามารถทำงานได้บนระบบปฏิบัติการ Windows เพียงอย่างเดียว ตารางเปรียบเทียบ ASP และ JSP
ASPJSP รูปแบบของการแทรกโค้ดจะคล้ายกัน จากตัวอย่าง ผลลัพธ์ที่ได้จะเหมือนกันคือ พิมพ์คำว่า Hello World และตามด้วยเวลาปัจจุบัน
1.5 เปรียบเทียบกับ Perl
ข้อดีที่ JSP อยู่เหนือจาก Perl คือความเร็ว เพราะว่า Perl เป็นภาษาสคริปต์เมื่อมีการเรียกให้สคริปต์ทำงานสคริปต์จะถูกโหลดเข้าสู่หน่วยความจำเพื่อคอมไพล์และประมวลผลไหม่ทุกครั้ง แต่ JSP นั้นจะมีการคอมไพล์เพียงครั้งเดียวและฝังอยู่ในหน่วยความจำตลอด ทำให้ความเร็วของ JSP เหนือกว่า Perl
1.6 จาวามีผลต่อการทำงานอย่างไร
บนระบบปฏิบัติการ Windows สิ่งหนึ่งที่ผู้ใช้ต้องเจอเมื่อใช้โปรแกรมจาวาต่างๆ เ ช่น Applet หรือ Application ก็คือความช้า เพราะโปรแกรมเหล่านั้น มักจะมีหน้าจอ GUI (เช่น button, scroll bar ฯลฯ)ประกอบอยู่ด้วยเสมอ ทำให้มีงานที่ต้องวาดหน้าจอกราฟิกเพิ่มขึ้น แต่เมื่อเปรียบเทียบการทำงานบนระบบปฏิบัติการยูนิกซ์ แล้วจาวาจะทำงานได้เร็วมาก เพราะโปรแกรมเหล่านี้ไม่ต้องทำงานกับกราฟิกเลย จึงสรุปได้ว่าเมื่อไม่มีงานกราฟิก จาวาจะทำงานได้เร็ว JSP ซึ่งทำงานที่ฝั่งเซิร์ฟเวอร์ และไม่มีการทำงานเกี่ยวกับกราฟฟิกก็ทำงานได้เร็วเช่นกัน
1.7 จะต้องมีอะไรบ้างหากจะใช้ Java
คำตอบก็คือเว็บเซิร์ฟเวอร์ที่ทำงานกับ JSP ได้ มีหลายตัวตั้งแต่ชุด JSDKของ Sun Microsystems ไปจนถึงโปรแกรมสำเร็จรูปที่นำเอาชุด JSDK นี้มาประยุกต์ ได้แก่ - Tomcat จากค่าย Apache - ServletExec จากค่าย New Atlanta/Unify - Jrun จากค่าย Allaire - WebLogic จากค่าย BEA Systems - Websphere จากค่าย IBM ในที่นี้จะใช้ Tomcat จากค่าย Apache เพราะใช้งานง่ายและไม่มีค่าใช้จ่าย
2.1 การใช้งาน JSP
เครื่องคอมพิวเตอร์ของเราต้องติดตั้งส่วนประกอบ 3 ส่วน คือ
1. เว็บเซอร์ฟเวอร์ที่สามารถทำงานร่วมกับเอกสาร JSP ได้ ซึ่งจะขอเลือกใช้ Tomcat เวอร์ชัน 3.2.1 จากค่าย Apache เนื่องจากใช้ง่ายกินทรัพยากรของระบบน้อย และไม่ต้องเสียค่าใช้จ่าย
2. Java Development Kit หรือ JDK 1.3 จาก Sun Microsystems เพื่อใช้ในการสร้างคอมโพเนนต์บีนและใช้งานร่วมกับ Tomcat 3.2.1
3. โปรแกรมเอดิเตอร์เพื่อเขียนคำสั่ง JSP สำหรับโปรแกรมเอดิเตอร์นั้น จะใช้ ตัวใดก็ได้ ซึ่งจะขอเลือกใช้ Edit Plus 2.10c ซึ่งรู้จักโครงสร้างของเอกสาร JSP ทำให้การเขียนคำสั่งสะดวกขึ้น
2.2 ติดตั้ง Java Development Kit หรือJDK 1.31. ขั้นตอนการติดตั้ง เหตุผลที่ต้องติดตั้ง JDK ก็เพราะว่า Tomcat จำเป็นต้องใช้องค์ประกอบหลายอย่างของ JDK เวลาที่มันทำงาน เช่น java.exe เป็นต้น
1.1 ดับเบิลคลิกที่ไฟล์เพื่อเริ่มติดตั้ง JDK 1.3
1.2 เลือกปุ่ม Next ไปเรื่อย ๆ จากนั้นให้เลือกไดเรกทอรีเพื่อทำการติดตั้ง โดยเลือกที่ไดเรกทอรีไหนก็ได้ ในที่นี้จะอ้างอิงที่ C:\JDK1.3 แล้วกดปุ่มNext อีกที2. การแก้ไขตัวแปร Path และ Class path เมื่อติดตั้ง JDK 1.3 เสร็จเรียบร้อยแล้ว จะต้องกำหนดตัวแปร Path และ Classpath การกำหนดค่าให้ตัวแปร Path นั้นก็เพื่อให้คอมไพเลอร์จาวา(JAVAC) สามารถเรียกจากที่ใดก็ได้นอกจากไดเรกทอรีที่ติดตั้งไว้ ส่วนตัวแปรClasspath นั้นช่วยให้โปรแกรมจาวาที่เราพัฒนาขึ้น สามารถเชื่อมโยงกับคลาสไลบรารีอื่นๆ ที่อยู่คนละไดเรกทอรีกันได้ ขั้นตอนการกำหนดตัวแปรทั้งสองมีดังนี้
2.1 คลิกขวาที่ My computer เลือกที่เมนู Properties
2.2 จะปรากฏไดอะล็อกบ็อกซ์ System Properties ให้คลิกที่แท็บ Advancedแล้วคลิกที่ปุ่ม Environment Variables
2.3 คลิกเลือกที่ตัวแปร Path ในช่องรายการ System Variables
2.4 เพิ่มเติมค่าที่ตัวแปร path เป็น C:\JDK1.3\BIN\;
2.5 คลิกเลือกตัวแปร Classpath
2.6 เพิ่มเติมค่าที่ตัวแปร Classpath เป็น C:\JDK1.3\jre\lib\;
2.7 จากนั้นให้คลิกปุ่ม OK ไปให้หมด ในการทดสอบว่าค่าตัวแปรที่เรากำหนดถูกต้องหรือไม่ ให้เรียก Command Prompt ขึ้นมา พิมพ์คำสั่งที่ Command Prompt ดังนี้ - พิมพ์คำสั่ง Path หากค่าที่แสดงออกมามีค่าที่เรากำหนดไว้รวมอยู่ด้วยคือ C:\JDK1.3\BIN\; แสดงว่าการติดตั้งถูกต้อง - พิมพ์คำสั่ง echo %classpath% หากค่าที่แสดงออกมามีค่าที่เรากำหนดไว้รวมอยู่ด้วยคือ C:\JDK1.3\jre\lib\; แสดงว่าการติดตั้งถูกต้องNote : สำหรับผู้ที่ใช้ระบบปฏิบัติการ Windows 95/98/Me ให้แก้ไขเพิ่มค่าตัวแปรPath และ Classpath ที่ไฟล์ autoexec.bat ดังนี้ - Path = C:\JDK1.3\BIN\; - Classpath = C:\JDK1.3\jre\lib\;แล้ว restart เครื่องเพื่อให้ค่าตัวแปรเปลี่ยนแปลงตามที่เรากำหนดไว้
2.3 ติดตั้ง Tomcat 3.2.11. ขั้นตอนการติดตั้ง
1.1 ดับเบิลคลิกที่ไฟล์เพื่อเริ่มติดตั้ง Tomcat 3.2.1
1.2 ทำการ Unzip ไฟล์ Tomcat 3.2.1
1.3 ให้เลือกไดเรกทอรี C:\ Tomcat เพื่อแตกไฟล์ที่ zip มา ไปเก็บไว้(สามารถเลือกไดเรกทอรีอื่น นอกเหนือจาก C:\ Tomcat ได้)2. แก้ไขตัวแปรต่างๆ เมื่อกอบปี้ไฟล์ต่าง ๆ ไปเก็บไว้ในไดเรกทอรีที่กำหนดแล้ว ขั้นตอนต่อไปจะต้องกำหนดตัวแปร เพื่อให้ Tomcat ทำงานได้ ประกอบไปด้วย 2 ตัวแปร คือตัวแปร TOMCAT_HOME กับ JAVA_HOME ดังนั้น ให้ไปยัง EnvironmentVariable อีกครั้ง แล้วเพิ่มตัวแปร 2 ตัว ดังนี้
2.1 เลือกที่ปุ่ม New เพื่อสร้างตัวแปรใหม่ใน System Variables
2.2 สร้างตัวแปร TOMCAT_HOME ใส่ค่าให้กับตัวแปรเป็นไดเรกทอรีที่เราเลือกติดตั้ง Tomcat ในที่นี้คือ C:\ Tomcat
2.3 สร้างตัวแปร JAVA_HOME ใส่ค่าให้กับตัวแปรเป็นไดเรกทอรีที่เราเลือกติดตั้ง JDK1.3 ในที่นี้คือ C:\JDK1.3 2.4 คลิกปุ่ม OK ไปให้หมดNote : สำหรับผู้ที่ใช้ระบบปฏิบัติการ Windows 95/98/Me ให้เพิ่มค่าตัวแปรทั้งสองตัวที่ไฟล์ autoexec.bat ดังนี้ - TOMCAT_HOME = C:\ Tomcat ; - JAVA_HOME = C:\JDK1.3;แล้ว restart เครื่องเพื่อให้ค่าตัวแปรเปลี่ยนแปลงตามที่เรากำหนดไว้3. ความหมายของไดเรกทอรีต่าง ๆ ไดเรกทอรีที่สำคัญใน ไดเรกทอรี C:\ Tomcat มีดังนี้
1. Directory
2. Content
4. ทดสอบการใช้งาน เมื่อติดตั้ง Tomcat เรียบร้อยแล้ว เราจะมาทดสอบว่าขั้นตอนที่เราติดตั้งนั้น สามารถทำงานได้หรือไม่
1. ให้เรียก Command Prompt ขึ้นมาแล้วเข้าไปในไดเรกทอรีที่ติดตั้งTomcat ไว้ ในที่นี้คือ C:\Tomcat จากนั้นให้เข้าไปในไดเรกทอรี bin เพื่อเรียกTomcat จากไฟล์ StartUp.bat
2. เมื่อเรียกไฟล์ StartUp.bat แล้ว จะปรากฏ Command Prompt อีกหน้าต่าง ชื่อว่า Tomcat3.2 ขึ้นมาและ Command Prompt จะค้างอยู่ทั้ง 2 หน้าต่างหากมีอันใดปิดไปเอง แสดงว่ามีข้อผิดพลาดเกิดขึ้นให้ไปดูไฟล์ log ในไดเรกทอรี Logs แต่หากหน้าต่าง Tomcat 3.2 ปรากฏค้างอยู่แสดงว่า การติดตั้งเสร็จสมบูรณ์ สำหรับค่าเริ่มต้นนั้น Tomcat จะทำงานที่พอร์ต 8080 หากลงเซิร์ฟเวอร์ตัวอื่น เช่น จาวาเซิร์ฟเวอร์ซึ่งทำงานที่พอร์ตนี้เช่นกัน ให้ไปเปลี่ยนค่าพอร์ตของ Tomcat ในไฟล์ conf เพื่อไม่ให้พอร์ตชนกัน
2.4 ติดตั้ง Edit Plus 2.10c
สำหรับเอดิเตอร์เพื่อเขียนเอกสาร JSP นั้น สามารถใช้อะไรก็ได้ เช่น โน้ตแพด แล้วบันทึกไฟล์เหล่านั้นเป็นนามสกุล jsp ไปเก็บไว้ในไดเรกทอรีภายใต้ C:\Tomcat\webapps\Tutorial แต่ขอแนะนำ Edit Plus เพราะเป็นโปรแกรมเอดิเตอร์ ที่รู้จักโครงสร้างของเอกสาร JSP ทำให้สะดวกในการเขียน โดยให้ดับเบิลคลิกเพื่อเริ่มติดตั้ง เมื่อติดตั้งเสร็จสมบูรณ์ จะทำการแก้ไขให้ Edit Plus สามารถแสดงผลโครงสร้างของเอกสาร JSP ได้ดังนี้
1. เปิดโปรแกรม Edit Plus ขึ้นมา แล้วคลิกเมนู File-> New-> others
2. จะปรากฏไดอะล็อกบ็อกซ์ Select File Type ให้คลิกเลือก JSP จากนั้นให้กดปุ่ม OK
3.1 พื้นฐานสำคัญในจาวา
ส่วนใหญ่คงเคยเขียนโปรแกรมแบบ Imperative หรือ Procedural มาแล้วแนวความคิดในการเขียนโปรแกรมแบบ Imperative คือ การสร้างโปรแกรมด้วยลำดับของคำสั่งคอมพิวเตอร์ มีการสร้างโพรซีเจอร์เพื่อเก็บส่วนโปรแกรมที่ทำงานบ่อยๆข้อเสียของวิธีนี้คือ เป็นการยากที่จะความเข้าใจกับโปรแกรมว่าโปรแกรมทำงานอะไร ยิ่งถ้าโปรแกรมมีขนาดใหญ่ๆ จะทำความซับซ้อนมากขึ้นไปด้วย แต่เมื่อเปรียบเทียบโปรแกรมเชิงวัตถุ(Object Oriented Programming)ซึ่งจำลองการทำงานของวัตถุได้ใกล้เคียงกว่า โดยใช้หน่วยโปรแกรมที่เรียกว่าคลาส(Class) ซึ่งมีทั้งข้อมูลและฟังก์ชันรวมอยู่ด้วยกัน ทำให้การทำความเข้าใจต่อโปรแกรมและการสร้างจะทำได้ง่ายกว่า ภาษาจาวาจึงเลือกใช้แนวความคิดแบบเชิงวัตถุเป็นส่วนใหญ่และยกเว้นให้มีการคิดและออกแบบโปรแกรมแบบ imperativeได้ แต่เนื่องจากเป็นภาษาเชิงวัตถุอย่างแท้จริง ถ้าผู้พัฒนาโปรแกรมคิดและสร้างโปรแกรมแบบเชิงวัตถุก็จะถือว่าได้ใช้ประโยชน์จากภาษาจาวาได้เต็มที่
3.2 การเขียนโปรแกรมเชิงวัตถุ (Object Oriented Programming)
ลองมองวัตถุที่อยู่รอบๆตัวเราดูจะสังเกตเห็นว่าวัตถุทั่วไปในธรรมชาตินั้นประกอบ ด้วย สถานะ(State) , คุณสมบัติ(Behavior) และพฤติกรรม เป็นของตัวเองยกตัวอย่างเช่น รถยนต์ มีคุณสมบัติ(Property) เช่น สี ขนาด น้ำหนัก ราคา ส่วนพฤติกรรม(Behavior)ก็มีเช่น เดินหน้า ถอยหลัง เบรก และสถานะ(State) ก็เช่น ความเร็ว จำนวนน้ำมัน ความร้อนของเครื่องยนต์ การเขียนโปรแกรมเชิงวัตถุก็คือการจำลองวัตถุทั้ง สถานะ คุณสมบัติ และพฤติกรรม โดยการนำแนวความคิดของคลาสมาใช้ คือสร้างแม่แบบของวัตถุขึ้นมาก่อน แล้วจึงทำแม่แบบนั้นให้มีตัวตนขึ้นมา โดยสร้างสิ่งที่เรียกว่าอินสแทนซ์(Instance)ของคลาสนั้นขึ้นมา ยกตัวอย่างในโลกความจริงอินสแทนซ์ของคลาสรถยนต์คือ รถยนต์ยี่ห้อต่างๆไม่ว่าจะเป็น BMW , BENZ , Volvo เป็นต้น ส่วนในทางคอมพิวเตอร์การสร้างคลาสคือการสร้างส่วนของโปรแกรมตามรูปแบบของจาวาส่วนหนึ่งขึ้นมาก่อน แล้วจึงสร้างอินสแทนซ์ด้วยการใช้คลาสนั้น
3.3 โครงสร้างพื้นฐาน
ภาษาจาวามีไวยากรณ์ที่คล้ายกับภาษา C และ C++ หรือแม้กระทั่ง C#สำหรับคำ , สัญลักษณ์ และไวยากรณ์ของจาวาแบ่งออกได้ดังนี้
3.3.1 Comment คือ ข้อความที่แทรกเข้าไปในตัวโปรแกรมเพื่ออธิบายการทำงานของโปรแกรมโดยไม่มีผลกระทบใดๆต่อโปรแกรม มีการประกาศได้ 3 แบบคือ 1. /*ข้อความ*/ 2. //ข้อความ 3. /**ข้อความ*/
3.3.2 Keywords คือ คำสงวนหรือคำที่กำหนดความหมายไว้แล้ว ไม่สามารถตั้งชื่อให้เหมือนได้มี 50 คำเช่น true , try , void , while , if , else , int เป็นต้น
3.3.3 Identifiers คือ ชื่อที่ผู้เขียนโปรแกรมสามารถตั้งเองได้ อาจเป็นชื่อคลาส ตัวแปรหรือเมธอด โดยชื่อที่ถูกต้องสามารถประกอบไปด้วย ตัวอักษรใหญ่ ตัวอักษรเล็กตัวเลข เครื่องหมาย_ หรือ $ เช่น myBook2 , $money , go_west แต่ชื่อที่ตั้งขึ้นจะต้องไม่ขึ้นต้นด้วยตัวเลขและห้ามมีสัญลักษณ์อื่น
3.3.4 Separators คือ สัญลักษณ์ที่ใช้สำหรับแบ่งแยกคำในภาษามีดังนี้ - เครื่องหมาย ‘(’ และ ‘)’ ใช้สำหรับต่อท้ายชื่อเมธอด ระบุเงื่อนไขในประโยคควบคุมเช่น if (condition) then-else - เครื่องหมาย ‘{’ และ ‘}’ ใช้สำหรับกำหนดค่าเริ่มต้นแก่ Array กำหนดขอบเขตของบล็อกเมธอด และคลาส - เครื่องหมาย ‘[’ และ ‘]’ ใช้สำหรับระบุในการประกาศตัวแปรที่มีชนิดเป็นarray และกำหนดค่า index ของสมาชิกใน array เช่น a[1] , a[2,3] เป็นต้น - เครื่องหมาย ‘;’ ใช้ปิดเพื่อจบประโยคทุกครั้ง - เครื่องหมาย ‘,’ ใช้เพื่อแยกชื่อตัวแปรตอนประกาศ เช่น int a,b; - เครื่องหมาย ‘.’ ใช้เพื่อเข้าถึงเมธอด คลาส เช่น Car.move();
3.3.5 Operators ประกอบไปด้วยประเภทต่างๆดังต่อไปนี้ - Floating Point และ Integer Arithmetic Operators ได้แก่ +(บวก) , -(ลบ) ,*(คูณ) , /(หาร) และ %(มอดูลัส) เช่น ? จะได้ 0 - Arithmetic Assignment Operator คือ += , -= , *= , /= และ %= ความหมายของoperatorเหล่านี้ก็คือการละการพิมพ์ชื่อตัวแปรอีกตัว ยกตัวอย่างเช่น x+=y;ก็คือ x=x+y; นั่นเอง - Increment and Decrement Operators มี 2 ตัวคือ ++ และ - เช่น x++;เทียบเท่ากับ x=x+1; - Bitwise Operator Assignment ได้แก่ &= , = , ^= เป็นต้น - Relational Operator ได้แก่ = = (เท่ากับ) , != (ไม่เท่ากับ) , < (น้อยกว่า) ,> (มากกว่า) , < = (น้อยกว่าหรือเท่ากับ) และ > = (มากกว่าหรือเท่ากับ) - Boolean Logical Operators ได้แก่ &(AND) , (OR) และ !(NOT)
3.4 ชนิดข้อมูลและตัวแปร
ภาษาจาวาเป็นภาษาที่เข้มงวดกับความถูกต้องของข้อมูลสูงต่างกับภาษาบางชนิดที่ไม่จำเป็นต้องระบุชนิดของข้อมูล ชนิดข้อมูลพื้นฐานคือ ชนิดข้อมูลที่ค่าไม่สามารถแตกย่อยเป็นส่วนประกอบอื่นๆได้อีก เช่น ตัวเลข ตัวอักษร และบูลีน โดยมีลักษณะดังนี้ชนิดของข้อมูลขนาดของข้อมูลค่าดีฟอลต์ค่าที่เก็บได้ สำหรับ Array และ String นั้นไม่ใช่ชนิดข้อมูลแต่เป็นคลาสที่จาวาเตรียมมาให้ การประกาศตัวแปรเพื่อเก็บค่าข้อมูลต่างๆ จะมีโครงสร้างดังต่อไปนี้ Type identifier [ = value];โดยที่ Type คือชนิดของข้อมูล Identifier คือชื่อของตัวแปร เราสามารถกำหนดค่าเริ่มต้นให้กับตัวแปรโดยใช้ [=value] ซึ่งจะให้ค่าเริ่มต้นหรือไม่ก็ได้ ตัวอย่างเช่น การประกาศตัวแปร a มีชนิดของข้อมูลเป็นจำนวนเต็ม มีรูปแบบคือ int a; การประกาศตัวแปร str มีชนิดของข้อมูลเป็นสตริง มีค่าเริ่มต้นเป็น “Hi !” มีรูปแบบคือ string str = “Hi !”; ลองเปิดโปรแกรมเอดิเตอร์ขึ้นมา พิมพ์โค้ดตาม source code ชื่อ dataType.jsp แล้วบันทึกไฟล์ชื่อ dataType.jsp ลงในไดเรกทอรีC:\Tomcat\WebApps\Tutorial\EXample\
3.5 คำสั่งควบคุม
คำสั่งควบคุมคือประโยคที่ใช้กำหนดการทำงานของโปรแกรมให้เป็นไปตามเงื่อนไข คำสั่งควบคุมในจาวามีดังนี้
3.5.1 คำสั่ง IF ใช้สำหรับให้โปรแกรมเลือกเดินทางใดทางหนึ่งระหว่างทางเลือก2ทางโดยใช้ผลลัพธ์ของเงื่อนไขในการตัดสินใจมีโครงสร้างดังนี้ if (expression)
3.5.2 คำสั่ง Switch คล้ายๆกับ if คือจะเลือกเส้นทางเพียงทางเดียว แต่จะมีเส้นทางให้เลือกได้หลายทางโดยใช้ค่าจำนวนเต็มหรือตัวอักษรเป็นตัวตัดสินใจ มีโครงสร้างดังนี้ Switch (expression) { case value1 :
3.5.3 คำสั่ง While เป็นประโยคที่ทำซ้ำจนเงื่อนไขบางอย่างเป็นเท็จจึงหยุดทำงาน โครงสร้างของคำสั่งคือ while (expression) {
3.6 เมธอด
ภาษาจาวามีโครงสร้างเป็นกลุ่มคำสั่ง(block) ซึ่งเป็นกลไกที่เราสามารถสร้างโปรแกรมย่อยหรือที่เราคุ้นเคยในชื่อโพซีเยอร์และฟังก์ชั่นนั่นเอง แต่ในภาษาจาวา เราเรียกชื่อว่า เมธอด(method)แทน การมีเมธอดนั้นทำให้เราสามารถแยกย่อยโปรแกรมทั้งหมดออกมาเป็นหน่วยย่อยได้ ซึ่งทำให้ง่าย ในการจัดการ โดยปกติเมธอดจะถูกกำหนดในคลาส โครงสร้างของเมธอดมีดังนี้ [modifier] [static]
3.6.1 [modifier] เป็นตัวเลือกคือจะมีหรือไม่มีก็ได้ มี 3 ตัวคือ public , private และ protectแต่ละตัวมีความหมายดังนี้ - public จะทำให้เมธอดสามารถอ้างจากนอกคลาสได้ - private จะทำให้ไม่สามารถอ้างอิงจากนอกคลาสได้ - protect ทำให้เมธอดสามารถอ้างอิงจากคลาสที่อยู่ใน package เดียวกันหรือคลาสที่ขยาย (Extend) มาจากคลาสนั้น หากไม่มีการระบุจะถือว่าใช้ protectเป็นค่า default
3.6.2 [static] เป็นตัวเลือกเช่นเดียวกัน หากเมธอดใดถูกระบุเป็น static จะถูกเรียกได้จากเมธอดอื่นๆ ที่อยู่ในคลาสเดียวกันหรือต่างคลาสโดยขึ้นกับเงื่อนไขดังนี้ - หากในคลาสเดียวกันเมธอด static จะเรียกได้แต่เมธอดที่เป็น staticเท่านั้น - หากเป็นเมธอดที่อยู่ต่างคลาสการเรียกจะเรียกผ่านชื่อคลาส โดยไม่จำเป็นต้องสร้างอินสแทรนซ์ของคลาสขึ้นมาก่อน
3.6.3 return type คือชนิดของข้อมูลที่จะผ่านกลับมาจากเมธอด หากไม่มีการส่งค่าออกมาให้ใส่ void ไว้หากมีการส่งก็ให้ระบุชนิดของข้อมูลได้เลยเช่น int , char เป็นต้น
3.6.4 method name คือชื่อของเมธอด สามารถตั้งชื่ออะไรก็ได้แต่ต้องถูกต้องตามหลักของภาษาด้วย
3.6.5 parameter เป็น option คือจะมีการผ่านค่าตัวแปรมาหรือไม่ก็ได้ หากมีมากกว่า 1 ตัวก็แยกด้วยเครื่องหมาย ‘-’ หรือถ้าไม่มีการผ่านค่าอะไรมาก็ใส่เครื่องหมาย () ไว้หลังชื่อเมธอดเฉยๆ
3.6.6 method body คือลำดับของประโยคที่เมธอดจะทำตามคำสั่ง เมื่อมีการเรียกและที่สำคัญหากกำหนดให้เมธอดมีการผ่านค่ากลับต้องใส่คำสั่ง return และตามด้วยค่าที่ส่งกลับเข้าไปด้วย เพื่อให้เห็นภาพชัดเจน ให้ลองพิมพ์โค้ดตาม source code ชื่อhelloWorld.jsp แล้วบันทึกชื่อไฟล์เป็น helloWorld.jsp ลงในไดเรกทอรีC:\Tomcat\WebApps\Tutorial\Example\อธิบาย Source Code ชื่อ helloWorld.jsp จากตัวอย่างนี้ได้ประกาศเมธอด addStr() ให้อยู่ภายใต้สัญลักษณ์< %! กับ % > (แท็กชนิดหนึ่งของ JSP) โดย modifier เป็น public,กำหนดให้ส่งผลลัพธ์ที่มีชนิดข้อมูลเป็นสตริงกลับ และรับค่าอากิวเมนต์ที่มีชนิดเป็นสตริงด้วยเช่นกัน เมื่อมีการเรียกเมธอดให้ทำงาน ผลลัพธ์ที่ได้คือ ค่าสตริงที่ส่งมาบวกคำว่า “Hello” และ “I Love U” จากนั้นก็ส่งผลลัพธ์กลับ สำหรับขั้นตอนการทำงานของเอกสารมีดังนี้ เมื่อผู้ใช้เปิดเอกสาร JSP ขึ้นมาและทำงานไปจนถึงบรรทัด if โปรแกรมก็จะตรวจสอบว่ามีการส่งค่าตัวแปรที่ชื่อว่า username มาหรือไม่โดยใช้คำสั่ง if ( request.getParameter(”username”) == null) โดยตรวจสอบค่าอากิวเมนต์ที่มากับออบเจ็กต์ request ว่าตัวแปรชื่อusername มีค่าหรือไม่ หากไม่มีเงื่อนไขก็จะเป็นจริงคือ request.getParameter(”username”) == null โปรแกรมก็จะแสดงฟอร์มเพื่อรอรับชื่อของผู้ใช้ แต่ในกรณีที่มีการกดปุ่มกรอกข้อมูลและกดปุ่ม submit ทำให้เกิดการส่งค่าตัวแปรมาแล้วโปรแกรมก็จะทำคำสั่ง } else { String msg = addStr(request.getParameter(”username”)); Out.print(”< h1>”+msg+ “< h1>”); } โดยจะส่งชื่อผู้ที่ใช้ป้อนเข้ามาส่งไปให้เมธอด addStr() จากนั้นก็นำค่าที่ส่งกลับมาจากเมธอดนี้แสดงผลที่หน้าจอ ตามปกติหากเราต้องการจะใช้ออบเจ็กต์ เราต้องสร้างอินสแทนซ์ขึ้นมาก่อน แต่จากตัวอย่างนี้จะสังเกตเห็นว่าเรียกใช้ออบเจ็กต์ out และ request โดยไม่มีการประกาศและสร้างอินสแทนซ์เลย ที่เป็นแบบนี้เพราะออบเจ็กต์ทั้งสองคือ Implicit Object ซึ่ง JSP Engine จะสร้างขึ้นมาให้เราโดยอัตโนมัติ
3.7 คลาส
คลาสคือโครงสร้างของสถานะ คุณสมบัติ และพฤติกรรมของวัตถุ ในภาษาจาวาคลาสก็เหมือนกับชนิดข้อมูลชนิดหนึ่ง การสร้างอินสแทนซ์ก็ต้องใช้คลาสเพื่อระบุว่าอินสแทนซ์ที่สร้างขึ้นมานั้นมีโครงสร้างอะไรบ้าง โดยอินสแทนซ์ที่เกิดมาจากคลาสเดียวกันก็จะมีโครงสร้างเหมือนกันทุกอย่าง ในการสร้างคลาสจะต้องมีการกำหนดสมาชิกของคลาสดังนี้ - ข้อมูล - ฟังก์ชัน หรือเมธอดดูตัวอย่างของคลาสรถยนต์ต่อไปนี้Class Car { public int color; private int price; String model; public void break () { } public void drive () { }} ลองนึกไปถึงเรื่องการโปรแกรมเชิงวัตถุ ตามโครงสร้างของคลาส Car จะมีคุณสมบัติ 3 อย่างคือ สี ราคา และชื่อรุ่น มีพฤติกรรมหรือเมธอด 2 ตัวคือ เบรกและขับเคลื่อน ตอนนี้เรามีเพียงแม่แบบเท่านั้น เราต้องสร้างตัวตนเพื่อให้รถยนต์ใช้งานได้จริงด้วยการสร้างอินสแทนซ์ของคลาสนี้ก็จะมีวิธีการประกาศดังนี้ Car myCar = new Car(); ตอนนี้ myCar จะจองพื้นที่ในหน่วยความจำเพื่อเก็บตัวแปรและเมธอดไว้แล้ว หากสรุปว่าเราอยากจะทราบว่ารถของเราที่สร้างมานั้นมีสีอะไรเราก็จะเรียกชื่อของอินสแทนซ์ นั้นแล้วคั่นด้วยจุดและตามด้วยชื่อคุณสมบัติซึ่งในที่นี้คือ สี รูปแบบการประกาศคือ MyCar.color;และหากเราอยากจะขับรถที่เราสร้างขึ้นมาก็มีวิธีการประกาศคล้ายๆกันคือ MyCar.drive(); เพื่อให้เห็นภาพที่ชัดเจนขึ้น เราจะนำความรู้เรื่องคลาสมาประยุกต์เพื่อมาสร้างเอกสาร JSP ที่อ่านค่าข้อมูลต่างๆของไคลเอนต์แล้วแสดงข้อมูลเหล่านั้นกลับมา ในลักษณะ HTML โดยใช้ออบเจ็กต์ที่สร้างขึ้นมาให้อัตโนมัติ(Implicit Object) 2 ตัวคือ Request กับ Out ให้เปิดโปรแกรมเอดิเตอร์ขึ้นมา พิมพ์โค้ดตาม source code ชื่อ SuperSnoop แล้วบันทึกไฟล์ชื่อsuperSnoop.jsp ลงในไดเรกทอรี C:\Tomcat\WebApps\Tutorial\Example\อธิบาย Source Code ชื่อ SuperSnoop จากตัวอย่างได้สมมุติคลาส client ขึ้นมาแทนเครื่องคอมพิวเตอร์ของผู่ใช้โดยกำหนดคุณสมบัติเครื่องของผู้ใช้ให้ประกอบด้วย ชื่อเครื่อง , พอร์ตที่ติดต่อกับเซิร์ฟเวอร์ , IP , URI และวิธีการติดต่อกับเซิร์ฟเวอร์ และให้มีพฤติกรรมคือการแสดงค่าคุณสมบัติต่างๆของตัวมันเอง เมื่อโปรแกรมเริ่มทำงานโปรแกรมจะสร้างออบเจ็กต์ชื่อ myClient ซึ่งเป็นอินสแทนซ์ของคลาส client แล้วจึงกำหนดคุณสมบัติต่างๆของตัวมันเอง โดยค่าที่เอามากำหนดนั้นได้จากออบเจ็กต์ request เมื่อกำหนดค่าคุณสมบัติครบแล้วเราก็จะแสดงผลค่าคุณสมบัติต่างๆที่อยู่ในตัวมัน โดยการเรียกเมธอด writeRowผลลัพธ์ที่แสดงออกมาก็จะประกอบด้วยค่าอากิวเมนต์ที่ส่งไปให้กับเซิร์ฟเวอร์ จะสังเกตว่าอากิวเมนต์ที่ส่งให้กับเมธอด write Row()นั้นจะมีออบเจ็กต์out สำหรับแสดงออกทางบราวเซอร์ด้วยออบเจ็กต์ out มีชนิดเป็น JspWriterอยู่ในคลาส javax.servlet.jsp
3.8 สถาปัตยกรรมของ JSP
ทุกครั้งที่มีการเรียกเอกสาร JSP ที่เราสร้างขึ้นมาทางบราวเซอร์ หากเป็นการเรียกครั้งแรกจะช้ากว่าการเรียกครั้งถัดไปเสมอเป็นเพราะอะไรลองพิจารณาขั้นตอนการทำงานแสดงขั้นตอนที่เกิดขึ้นเมื่อมีการเรียกเอกสาร JSP ในการเรียกครั้งแรก มีขั้นตอนดังต่อไปนี้
1. บราวเซอร์ร้องของเอกสาร JSP มายังเซิร์ฟเวอร์
2. เซิร์ฟเวอร์จะส่งผ่านการร้องขอนั้น ไปให้กับ JSP Engine
3. JSP Engine ก็จะคอมไพล์เอกสาร JSP นั้น
4. เมื่อการคอมไพล์ผ่าน โดยไม่มีข้อผิดพลาด JSP Engine ก็จะแปลงเอกสาร JSP นั้นให้เป็นชุดคำสั่งของ Servlet
5. ชุดคำสั่งของ Servlet เหล่านั้นก็จะถูกแปลงเป็นคลาส
6. เริ่มทำงานตามคำสั่งที่เขียนมา
7. เมื่อได้ผลลัพธ์แล้วก็จะส่งผลลัพธ์ในลักษณะเอกสาร HTML นั้นกลับไปให้เว็บเซิร์ฟเวอร์ เว็บเซิร์ฟเวอร์ก็ส่งผลลัพธ์ต่อไปให้กับบราวเซอร์อีกที ขั้นตอนเหล่านี้จะเกิดเพียงครั้งแรกครั้งเดียวเท่านั้น หากมีการเรียกครั้งต่อไป จะไม่ทำขั้นตอนที่ 3,4 และ 5 เนื่องจากการร้องขอเอกสาร JSP เป็นเอกสารตัวเดิมจึงไม่จำเป็นต้องคอมไพล์เป็นคลาสไฟล์ใหม่อีกครั้ง ยกเว้นว่ามีการแก้ไขเอกสาร JSP นั้น JSP Engine จึงต้องทำการคอมไพล์โค้ดอีกครั้ง
3.9 JSP Lifecycle
ในวงจรชีวิตของเอกสาร JSP นับตั้งแต่เกิดการ request เอกสารจนถึงการตอบสนองกลับ จากเซิร์ฟเวอร์นั้น JSP Engine จะใช้เมธอดสามตัวคือ jsplnit() ,jspDestroy() และ jspService() เพื่อจัดการกับเอกสาร JSP เมธอดทั้งสามตัวนี้จะเกิดขึ้นในขั้นตอนที่สี่ ซึ่งเอกสาร JSP จะถูกแปลงเป็น Servlet และมีการแทรกเมธอดต่อไปนี้เข้าไปNote : JSP กำหนดไว้ว่า ห้ามตั้งชื่อตัวแปรหรือเมธอดใดที่ขึ้นต้นด้วย jsp ,_ jsp ,jspx และ _jspx หากตั้งชื่อซ้ำจะทำให้โปรแกรมทำงานผิดพลาดjsplnit() เมธอดนี้จะทำงานเพียงครั้งเดียวเมื่อมีการเรียกเอกสาร JSP และจะทำงานเสร็จก่อนที่จะทำตาม request ที่เกิดขึ้น ประโยชน์ของเมธอดนี้ทำให้ผู้เขียนโปรแกรมสามารถกำหนดค่าเริ่มต้นให้กับตัวแปรหรือออบเจ็กต์ต่างๆ ได้ เช่น เชื่อมต่อฐานข้อมูลjspService() เมธอดหลักที่ใช้คือ _jspService เมธอดนี้จะถูกสร้างและจัดกรโดย JSPEngine เอง โดยผู้เขียนโปรแกรมจะไม่สามารถเกี่ยวข้องได้ หน้าที่หลักของเมธอดตัวนี้จะทำงานต่างๆที่ผู้เขียนโปรแกรมได้เขียนไว้ในเอกสาร JSPjspDestroy() เมื่อ Servlet ถูกโหลดออกจากหน่วยความจำ เมธอดนี้ก็จะถูกเรียกเพื่อทำงาน แต่เวลาที่จะเริ่มทำงานนั้นยจะไม่แน่นอนเพราะจะทำหลังจากโพรเซสอื่นทำงานหมดแล้ว หากเกิดการผิดพลาดของโพรเซสอื่นซึ่งทำให้เซิร์ฟเวอร์เกิดปัญหาขึ้น เมธอดนี้ก็จะไม่ทำงาน ประโยชน์ของเมธอดนี้ก็เพื่อคืนทรัพยากรต่างๆที่ได้จองไว้ เช่น ปิดการเชื่อต่อกับฐานข้อมูล เป็นต้น ในขั้นตอนที่สี่นั้นผลลัพธ์ที่ได้จะออกมาหน้าตาเป็นอย่างไร สมมุติว่าเอกสารJSP ที่ร้องขอไปมีโค้ดเป็นดังนี้< %!Public void jspInit() {// Read ค่า Counter}public void jspDestroy() {// เพิ่มค่า Counter ขึ้น 1}% >< html>< body>< % out.print(Counter); % >< /body>< /html> ผลลัพธ์หลังจากแปลงโคดแล้วจะออกมาเป็น Servlet แบบนี้(โค้ดที่แสดงให้ดูเป็นเพียงฉบับย่อที่ตัดมา หากเป็นฉบับโค้ดเต็มจะมีส่วนประกอบอื่นที่ยาวและซับซ้อนมากกว่านี้)Import javax.Servlet.*;Public classname extend HttpJspBase { Public init(){ // Read ค่า Counter } public service() { out.write(Counter); } public detroy() { // เพิ่มค่า Counter ขึ้น1 }}
4.1 Introduction
จากบทที่ผ่านมาคงสังเกตเห็นสัญลักษณ์ต่างๆ เช่น “< %” , “< %!” แต่ละตัวมีความหมายแตกต่างกันไป สัญลักษณ์เหล่านี้ก็คือ แท็กต่างๆ ของ JSP นั่นเองแบ่งออกได้เป็น 6 ประเภทดังนี้
1. Comment
2. Declaration
3. Expression
4. Directive
5. Scriptlet
6. Action
เรามาดูวิธีการประกาศและใช้งานกัน (ในบทนี้ไม่ได้กล่าวถึง Directiveอีกตัวคือ แท็ก Library เพราะเห็นว่าเป็นเรื่องที่ค่อนข้างจะเจาะลึกเกินไป และเราก็ยังไม่จำเป็นต้องสร้างแท็กขึ้นมาใช้งานเอง)
4.2 แท๊ก Comment
ภายในเอกสาร JSP เราสามารถเลือกใช้คอมเมนต์ได้สองชนิด คือ ในรูปแบบของ HTML คือ < ! - - Comment …… - - >ซึ่งคอมเมนต์ชนิดนี้จะมองเห็นเมื่อเรียกดูโค้ดของบราวเซอร์ หากไม่ต้องการให้คอมเมนต์ไปปรากฏที่บราวเซอร์ ต้องใช้คอมเมนต์อีกรูปแบบของ JSP คือ < % - - Comment ….. - - %>
4.3 แท๊ก Declaration
ชื่อก็บอกอยู่แล้วว่าเป็น Declaration คือการประกาศนั่นเอง แท็กนี้จะทำให้สามารถใช้โค้ดจาวาเพื่อประกาศตัวแปร, เมธอด หรือคลาสได้ รูปแบบในการใช้งานคือ <%! Declaration1; Declaration2; %> ก่อนจะเริ่มประกาศค่าต่างๆ เราก็ต้องใส่เครื่องหมาย <%! และเมื่อจบการประกาศแล้วก็ปิดด้วย %> และที่สำคัญโค้ดจาวาที่อยู่ในแท็กชนิดนี้จำเป็นต้องปิดด้วยเครื่องหมาย “;” ทุกครั้ง แท็ก Declaration จะไม่แสดงผลใดๆ ทั้งสิ้น แต่ค่าต่างๆ นี้จะนำไปใช้สำหรับการทำงานของโปรแกรม ยกตัวอย่างเช่น <%! private int counter = 0; private String getAccount(int accNo) %> จากตัวอย่างเราได้ประกาศค่าเพื่อนำค่าเหล่านี้ไปใช้ภายหลัง เมื่อเราเรียกเอกสาร JSP ขึ้นมาค่าต่างๆ ที่เราได้ประกาศไว้ก็จะถูกประมวลผลเมื่อเรียกเอกสารนั้นขึ้นมา
4.4 แท๊ก Expression
จากตัวอย่างในบทที่ผ่านมา จะเห็นว่าหากเราต้องการแสดงค่าต่างๆ ออกมาที่บราวเซอร์นั้นเราจะต้องเรียกใช้เมธอด out.print() การใช้คำสั่งนี้ในบางทีอาจจะไม่สะดวก แท็ก Expression จึงยอมให้มีการใช้รูแบบย่อของคำสั่ง out.print() มีรูปแบบการใช้งานคือ <%=[Value] or [Expression]%> การใช้งานจะเริ่มด้วยเครื่องหมาย <%= แล้วตามด้วยค่าหรือสมการที่ต้องการแสดงผล แล้วปิดด้วย %> สำหรับเครื่องหมาย “;” นั้นไม่ต้องใส่สำหรับแท็กชนิดนี้ แท็ก Expression จะเปลี่ยนค่าที่เราต้องการแสดงผลให้เป็นสตริงโดยอัตโนมัติไม่ว่าค่านั้นจะมีชนิดข้อมูลเป็นอะไรทำให้ใช้งานสะดวก เพราะเราสามารถเอาแท็ก Expression ไปแทรกในส่วนโค้ด HTML ได้ ตัวอย่าง เช่น
4.5 Directive
แท็ก Directive ชนิดนี้จะส่งข้อมูลบางอย่างไปบอกกับ JSP Engine ให้ทำงานตามและจะไม่แสดงผลข้อมูลเพียงแต่จะเปลี่ยนขั้นตอนการคอมไพล์ของ JSP Engine เท่านั้น มีรูปแบบการใช้งานคือ <%@ Directive Directive_attr_name = value %> การใช้งานจะเริ่มด้วยเครื่องหมาย <%@ แล้วตามด้วย directive และปิดด้วย %> ส่วนมากมักนิยมไว้บนสุดของเอกสาร JSP สำหรับ directive นั้นสามารถแบ่งย่อยออกได้เป็น 2 กลุ่มดังนี้1. Page Directive Page Directive จะบอก JSP Engine เพื่อกำหนดลักษณะของ page มี11 รูป แบบตามตาราง ชนิด ความหมาย รูปแบบ ตัวอย่างเช่น สมมุติว่าเราต้องการใช้คลาสในไลบรารี “java.sql” ทั้งหมดและให้ buffer = 16k สามารถกำหนดได้ดังนี้ <%@ page inport = “java.sql.*” buffer = “16k” %>2. Include Directive การใช้ Include Directive ทำให้เอกสาร JSP มีความสามารถในการนำเอกสาร HTML หรือเอกสาร JSP อื่นๆ เข้ามารวมกับตัวมันเองได้ มีรูปแบบการใช้คือ <%@ include file = URL %> เมื่อ JSP Engine ทำการคอมไพล์เอกสาร JSP ที่มี Directive ชนิดนี้ใส่อยู่ JSP Engine ก็จะนำส่วนของโค้ดในไฟล์ที่ระบุมารวมกัน ซึ่งเป็นการทำงานในแบบ compile time คือทำงานในขณะคอมไพล์ สำหรับค่าของ file นั้นก็คือ URL ของเอกสารที่เราต้องการจะนำมารวม โดยปกติจะใช้เพื่อนำเอาเอกสารที่แสดงผลเป็นประจำเช่น ตัวนับ เป็นต้น <%@ include file = URL %>
4.6 แท๊ก Scriptlet
จากที่เราใช้แท็ก Expression เพื่อแสดงผลข้อมูลในเอกสาร JSP โดยการใส่ค่าหรือสมการต่างๆ ไว้ในเครื่องหมาย <% = และ %> จะเหมาะสำหรับโค้ดที่มีความยาวไม่มาก แต่ถ้าโค้ดมีความยาวมากๆ ทำให้ยากที่จะใส่โค้ดที่เป็นสมการเข้าไป แท็ก Scriptlet จึงใช้เพื่อแก้ปัญหานี้ วิธีการประกาศก็คือ <% Statement 1; Statement 2; Statement 3; Statement n; %> การประกาศจะเริ่มด้วย <% และ จบด้วย %> สำหรับแท็ก Scriptlet นี้สามารถแสดงผล output ออกมาได้เหมือนกัน วิธีการก็ใช้คำสั่ง out.print ของเราเหมือนเดิม ทีนี้อาจสงสัยว่า แล้วจะเลือกใช้อะไรดีระหว่าง Expression และ Scriptlet คำตอบก็คือ หากส่วนของโค้ดยาวมากๆ ก็เขียนลงใน Scriptlet จะเหมาะสมกว่า ลองดูตัวอย่างของการผสมการใช้งานของ Scriptlet , Expression , Directiveและ Declaration เพื่อความเข้าใจเพิ่มขึ้นให้เปิดโปรแกรมเอดิเตอร์ขึ้นมาพิมพ์โค้ดตาม Source Code ชื่อ fileCounter.jsp แล้วบันทึกไฟล์ชื่อ fileCountter.jsp ลงในไดเรกทอรี C:\Tomcat\WebApps\Tutorial\Example\อธิบาย Source Code ชื่อ fileCounter.jsp จาก Source Code ชื่อ fileCounter.jsp เป็นตัวอย่างของตัวนับเพื่อนับจำนวนครั้งที่เอกสารนี้ถูกเปิด โดยค่าของจำนวนครั้งจะเก็บอยู่ในไฟล์ counter.txtสมมุติว่ามีไฟล์นี้อยู่ในไดเรกทอรีC:\Tomcat\webapps\tutorial\Example\เพราะไม่ต้องการให้โค้ดยาว ดังนั้นต้องสร้างไฟล์นี้ก่อนที่จะเรียกเอกสาร JSPสำหรับค่าในไฟล์ก็พิมพ์ตัวเลขอะไรก็ได้ตั้งแต่ 0 ขึ้นไป สำหรับการทำงานตัวอย่างมีส่วนประกอบหลัก 3 ส่วนคือ Directive , Declaration และ Scriptletอธิบายแต่ละส่วนได้ดังนี้- Directive ในตัวอย่างนี้มีการเรียกใช้คลาส FileInputStream , DataInputStream ,FileOutputStream และ DataOutputStream เพื่อจัดเก็บไฟล์ Counter.txt ซึ่งคลาสเหล่านี้จะอยู่ในคลาสไลบรารี ” java.io.*” ดังนั้นจึงต้อง import คลาสเหล่านี้ก่อน รูปแบบการประกาศมีดังนี้ <%@ page import = ” java.io.*”%>- Declaration ประกาศตัวแปรเพื่อนำไปใช้ต่อไปในส่วนของ Scriptlet มีตัวแปรที่ประกาศคือ counter เพื่อเก็บค่าที่อ่านได้จากไฟล์ counter.txt และ path เพื่อเก็บที่อยู่ของไฟล์ counter.txt- Scriptlet เริ่มทำงานโดยการสร้างออบเจ็กต์ countFile จากคลาส FileInputStreamโดยออบเจ็กต์นี้จะแทนไฟล์ counter.txt หลังจากนั้นก็จะเริ่มอ่านไฟล์โดยสร้างออบเจ็กต์ countData จากคลาส DataOutputStream โดยเรียกเมธอด CountData.readInt () ผลลัพธ์ที่ผ่านกลับมาจากเมธอดนี้จะเป็นค่าจำนวนเต็ม เมื่ออ่านค่ามาได้แล้วก็เพิ่มค่าขึ้นครั้งละหนึ่งและแสดงผล พร้อมกับนำค่าที่เพิ่มขึ้นเขียนลงไฟล์counter.txt อีกครั้ง โดยสร้างออบเจ็กต์ countFile จากคลาส FileOutputStreamและเขียนไฟล์โดยสร้างออบเจ็กต์ countData จากคลาส DataOutputStreamโดยเรียกเมธอด countData.writeInt ( counter ) ; อากิวเมนต์ที่ผ่านให้กับเมธอดนี้ต้องมีชนิดเป็นจำนวนเต็ม และสิ่งสำคัญเวลาดำเนินการกับไฟล์จำเป็นต้องดักจับข้อผิดพลาด มิฉะนั้นเวลาเรียกเอกสารจะเกิด Exception ขึ้น
ไม่มีความคิดเห็น:
แสดงความคิดเห็น