JSP คืออะไร

1.1 อะไรคือ JSP
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) ; [ else ;] สำหรับexpression นั้นจะต้องมีค่าบูลีนเท่านั้น สำหรับคือประโยคหรือกลุ่มประโยคก็ได้ สำหรับ else นั้นจะมีหรือไม่มีก็ได้ ยกตัวอย่างเช่น < % if (a < =5 ) a = 5; % > หรือมี else ต่อท้าย < % if (a < = 5 ) a = 5; else a = 0; % > ประโยค if จะตรวจสอบค่า a ว่าน้อยกว่า 5 หรือไม่ หากเป็นจริงก็จะเข้าไปทำประโยค a=5 คือการใส่ค่า 5 ให้กับตัวแปร a
3.5.2 คำสั่ง Switch คล้ายๆกับ if คือจะเลือกเส้นทางเพียงทางเดียว แต่จะมีเส้นทางให้เลือกได้หลายทางโดยใช้ค่าจำนวนเต็มหรือตัวอักษรเป็นตัวตัดสินใจ มีโครงสร้างดังนี้ Switch (expression) { case value1 : ; case value1 : ; ………………………….. default : ;] } ในประโยค switch นั้นจะมีกี่ case ก็ได้ และมี default เป็นตัวเลือกคือจะมีหรือไม่มีก็ได้ โดยexpression ต้องมีค่าเป็นเลขจำนวนเต็มหรือตัวอักษรเท่านั้น เช่น < % switch (ch) { case ‘a’ : out.print(’A'); case ‘b’ : out.print(’B'); case ‘c’ : out.print(’C'); case ‘d’ : out.print(’D'); default: out.print(’-'); } % > ประโยค switch จะพิมพ์ค่าของอักษรที่ตรงกับ case ต่างๆเช่น หากตัวแปร a เก็บอักษรคือ a ก็จะพิมพ์ค่า ‘A’ หรือหากไม่มีค่าใดที่ตรงกับเงื่อนไขประโยคก็จะไปตกที่ default และจะพิมพ์ค่า ‘-’
3.5.3 คำสั่ง While เป็นประโยคที่ทำซ้ำจนเงื่อนไขบางอย่างเป็นเท็จจึงหยุดทำงาน โครงสร้างของคำสั่งคือ while (expression) { ; } ความหมายของประโยคนี้คือเมื่อโปรแกรมเดินมาถึงคำสั่ง while ก็จะคำนวณเงื่อนไขว่าเป็นจริงหรือไม่ หากจริงก็จะเข้าไปทำ statement ต่างๆ ในประโยค เมื่อทำหมดแล้ว ก็จะกลับมาคำนวณเงื่อนไขอีก ประโยคจะทำซ้ำจนกระทั่งเงื่อนไขเป็นเท็จเท่านั่น โดยexpressionต้องเป็นบูลีน เช่น < % while (a <> โปรแกรมจะตรวจสอบว่า a <>; } โดย expression ทั้งหมดต้องเป็นบูลีนเช่นเดียวกันซึ่ง expression ตัวแรกจะมีหรือไม่ก็ได้ expression ตัวที่สองจะเป็นการคำนวณว่าเงื่อนไขเป็นจริงหรือไม่ ส่วนตัวที่สามใช้สำหรับทำประโยคที่เกี่ยวกับเงื่อนไข < % for (int i = 0; i <> โปรแกรมนี้มีการทำงานเหมือนกับโปรแกรมคำสั่ง while คือพิมพ์ค่า iจำนวน 10 ครั้งออกมาที่หน้าจอ

3.6 เมธอด
ภาษาจาวามีโครงสร้างเป็นกลุ่มคำสั่ง(block) ซึ่งเป็นกลไกที่เราสามารถสร้างโปรแกรมย่อยหรือที่เราคุ้นเคยในชื่อโพซีเยอร์และฟังก์ชั่นนั่นเอง แต่ในภาษาจาวา เราเรียกชื่อว่า เมธอด(method)แทน การมีเมธอดนั้นทำให้เราสามารถแยกย่อยโปรแกรมทั้งหมดออกมาเป็นหน่วยย่อยได้ ซึ่งทำให้ง่าย ในการจัดการ โดยปกติเมธอดจะถูกกำหนดในคลาส โครงสร้างของเมธอดมีดังนี้ [modifier] [static] ([type parameter]) { } ลองมาดูโครงสร้างเมธอดกันทีละตัว
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 ได้ ตัวอย่าง เช่น <%= “Name” %> <%= “Age” %>

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 ขึ้น

What is Java DB?

What is Java DB?
Java DB is Sun's supported distribution of the open source Apache Derby 100% Java technology database. It is fully transactional, secure, easy-to-use, standards-based — SQL, JDBC API, and Java EE — yet small, only 2MB. The Apache Derby project has a strong and growing community that includes developers from large companies such as Sun Microsystems and IBM as well as individual contributors.

"We think Derby's best "feature" is its wide domain of applicability - that is it can be used anywhere from say a very small embedded database like say SQLite, all the way up to concurrent database applications matching MySQL, etc.," says Matt Doran of PaperCut Software.
"I recently did a presentation about Apache Derby at the Australian Java User's Group meeting in Melbourne. The presentation was titled "Using Apache Derby in the real world". Its focus was not so much on how to use Derby, but where it can be used and how it stands up in real world applications. We use Derby in our print accounting application called PaperCut, and feel that it's one of the "gems" of the Java community. Even though we offer a choice of MS SQL Server, Oracle and Postgres within PaperCut, we find that 90% of our 10,000+ users stick with Derby - the default embedded option."
Download the presentation for more information.

Where is Java DB in Sun Products?Java DB is currently included with the Java SE Development Kit; Java Enterprise System as the Application Server's developer database, and the Portal Server and Service Registry's data stores; it is supported by NetBeans 5.0, Java Studio Enterprise and Java Studio Creator; and, it is included as the out-of-the-box development database in the Sun Java Application Server PE 8.2 and the open community Glassfish implementation.

Java DB is ideal for:Departmental Java client-server applications that need up to 24 x 7 support and the sophistication of a standards-based, transactional SQL database that protects against data corruption or systems crashes without also requiring a database administrator.
Java application development and testing because it's full-featured though extremely easy-to-use, can fit on a laptop or run on a mainframe, and it's available at no cost under the Apache license.
Embedding in applications so that there is no need for the developer or the end-user to buy / download, install, administer — or even be aware of — the database separately from the application or IDE.
Multi-platform use due to Java portability. And, because Java DB is fully standards-compliant and 100% Java, it is easy to migrate an application using Java DB to other open standard databases.
Use within browser-based, Web (2.0) applications for easy distribution, one-click install, secure local data storage, and data persistence if the Internet connection is lost or for use off-line.
Applications running in a J2ME CDC (e.g., PDA) environment that need a small size (2MB) without sacrificing functionality: full SQL support, transaction management, stored procedures, triggers, concurrency, and backups.

JDBC คืออะไร

JDBC คืออะไร
JDBC คือ ตัวเชื่อมต่อระหว่างโปรแกรมกับฐานข้อมูลโครงสร้างของ JDBCเป็นกลุ่มอินเทอร์เฟซของจาวาที่เรียกว่า ไดรเวอร์ (Driver) ฐานข้อมูลแต่ละประเภทก็มีไดรเวอร์ต่างชนิดกันออกไป แต่เราไม่จำเป็นต้องรู้ถึงโครงสร้างของฐานข้อมูลที่เราต้องการจะติดต่อ เพียงแค่รู้ชนิดของไดรเวอร์ที่ใช้ในฐานข้อมูลชนิดนั้นก็พอเมื่อ JSP ต้องการติดต่อกับฐานข้อมูล ก็จะทำผ่านทาง JDBC APIและ JDBC Driver Manager ส่วนไดรเวอร์จะเป็น ODBC’ Oracle’ Sybaseหรือฐานข้อมูลชนิดอื่นก็ได้ สำหรับไดรเวอร์ของฐานข้อมูลอื่น ๆ นั้น ต้องติดตั้งเอง
วิธีการก็คือเมื่อได้ไดรเวอร์มาแล้ว (ไดรเวอร์จะอยู่ในรูปแบบของคลาสหรือแพ็กเกจ)ก็นำไดรเวอร์มาติดตั้งในไดเรกทอรีที่มีอยู่ในตัวแปร classpath สำหรับในบทนี้จะใช้ไดรเวอร์ ODBC ซึ่งมีอยู่แล้วในคลาส “java.sql.*” สามารถใช้ได้เลย
JDBC ( Java Database Connectivity) คือ Java API ที่ใช้สำหรับตีความคำสั่งSQL โดยประกอบด้วยชุดของ classes และ interfaces ที่เขียนด้วยโปรแกรมภาษา Java ตัว JDBC นี้เป็นAPI มาตรฐาน สำหรับการพัฒนาระบบฐานข้อมูล และทำให้มีความเป็นไปได้ในการเขียนโปรแกรมใช้งานเกี่ยวกับฐานข้อมูลด้วย JavaAPI เพียงอย่างเดียว
การใช้ตัว JDBC นี้ทำให้ง่ายในการส่งคำสั่ง SQL ให้กับระบบฐานข้อมูลชนิดต่างๆในรูปแบบเดียวกัน นั่นคือ JDBC API จะไม่บังคับให้เขียนโปรแกรมตัวหนึ่งเพื่อใช้กับฐานข้อมูลของ Sybase และอีกโปรแกรมหนึ่งสำหรับฐานข้อมูลของOracle และอีกหนึ่งโปรแกรมสำหรับฐานข้อมูลของ Informix และอีกหลายโปรแกรมสำหรับฐานข้อมูลชนิดต่างๆเราสามารถเขียนโปรแกรมโดยใช้ JDBC API เพียงโปรแกรมเดียว และโปรแกรมนั้นจะสามารถส่งคำสั่ง SQL ไปยังฐานข้อมูลชนิดต่างๆนั้นได้ และการเขียนโปรแกรมโดยใช้ภาษา Java นี้คุณก็ไม่ต้องกังวลว่าจะต้องเขียนโปรแกรมอีกหลายตัวเพื่อนำไปใช้กับคอมพิวเตอร์ที่อยู่บนplatform ชนิดต่างๆ เลย ในการรวมตัวกันระหว่าง Java และ JDBC นี้ ทำให้ผู้เขียนโปรแกรมสามารถเขียนโปรแกรมเพียงหนึ่งโปรแกรมแล้วสามารถนำไปใช้ได้ในทุกๆ แห่งที่ต้องการ
Java ที่กำลังแข็งขัน มีความปลอดภัย ง่ายต่อการใช้ ง่ายต่อการเข้าใจและ ถ่ายโอนข้อมูลมาได้อย่างอัตโนมัติบนระบบเครือข่าย เป็นโปรแกรมภาษาที่ฉลาดมากที่จะใช้เขียนโปรแกรมที่ใช้จัดการฐานข้อมูลและตัว JDBC ก็เป็นทางเลือกที่ต้องการเพื่อจะให้โปรแกรมตัวนั้นสามารถติดต่อกับฐานข้อมูลไม่ว่าฐานข้อมูลชนิดนั้นจะเป็นชนิดใดก็ตาม
JDBC เป็นส่วนขยายของความสามารถที่ Java ทำได้ นั่นคือ เมื่อใช้Java และ JDBC API เราสามารถเผยแพร่ web page ที่มี java applet ที่ใช้ข้อมูลจาก ฐานข้อมูลที่อยู่ที่แห่งอื่นได้หรือในบริษัทต่างๆ ก็สามารถใช้ JDBC เพื่อติดต่อพนักงานเข้ากับฐานข้อมูลต่างๆไม่ว่าพวกเขาจะใช้เครื่องบน Windows, Macintosh หรือ UNIX ก็ตามบนระบบอินทราเน็ต และในขณะนี้ความต้องการของการเข้าถึงฐานข้อมูลที่ง่ายจาก Java กำลังมีเพิ่มสูงขึ้นเรื่อยๆ กับผู้เขียนโปรแกรมJava จำนวนมาก
ผู้ที่จัดการ MIS ชอบที่จะรวม Java และ JDBC เข้าด้วยกันเพราะมันทำให้การเผยแพร่ข้อมูลทำได้ง่ายและประหยัด ในบริษัทสามารถใช้ฐานข้อมูลที่ได้ติดตั้งไว้ก่อนแล้ว และการเข้าถึงข้อมูลก็ทำได้ง่ายแม้ว่ามันจะอยู่ในระบบจัดการฐานข้อมูลต่างชนิดกันก็ตาม ในการพัฒนาโปรแกรมตัวใหม่จะใช้เวลาน้อยลง การติดตั้งและการดูแลเรื่องversion ก็ง่ายมาก โดยผู้เขียนโปรแกรมสามารถเขียนหรือแก้ไขโปรแกรมเพียงโปรแกรมเดียวแล้วนำไปไว้ที่เครื่อง server จากนั้นทุกๆคนก็จะสามารถเข้าถึงข้อมูลแบบ version ล่าสุดได้ทันที และสำหรับธุรกิจบริการข้อมูลการขาย Java และ JDBC เป็นหนทางที่ดีที่สุดที่จะนำเสนอข้อมูลที่แก้ไขล่าสุดให้กับลูกค้าข้างนอกของตน


ลักษณะที่สำคัญของ JDBC
JDBC เป็น low-level Interface ซึ่งสามารถเรียกใช้คำสั่ง SQL ได้โดยตรงซึ่งสามารถใช้งานได้อย่างมีประสิทธิภาพ,มีขนาดเล็กและง่ายต่อการใช้กว่าตัวติดต่อ Data Base ชนิดอื่น ๆ แต่ก็ได้มีออกแบบสำหรับใช้งานแบบ High-Level Interface ด้วย ซึ่ง High Level Interface คือ User Friendly ซึ่ง High-level API ของ JDBC ที่ถูกพัฒนาซึ่งมีดังนี้1. JDBC ต้องการคำสั่ง SQL ที่จะทำการส่งเป็น String ไปยัง Method ของภาษา Java ทำให้ Programmer สามารถใช้ตัวแปรในการรับส่งคำสั่ง SQL ได้2. มีการแปลง relation DataBase Table ไปเป็น Java Class ซึ่งเรียกว่า Object/Relational ซึ่งแต่ละแถวของ Table จะถูกแปลงไปเป็น Instant ของ Class และแต่ละ Column จะเป็นเหมือน attribute ของ Class ซึ่ง Programmer สามารถดำเนินการต่าง ๆ คล้ายด้วยว่า Table เป็น Class Class หนึ่ง ใน Java


ข้อดีของ JDBC
1. ใช้งานง่าย การตั้งค่าไม่ยุ่งยาก
2. สามารถทำงานร่วมกับภาษา Java ได้เป็นอย่างดี เพราะ Driver ที่เขียนขึ้นนั้นส่วนมากจะพัฒนาจากภาษา Java และมีการ compile เป็น class file ทำให้ใช้งานง่าย
3. สามารถติดต่อฐานข้อมูลได้เกือบทุกประเภท ซึ่งส่วนใหญ่จะเป็นฐานข้อมูลแบบเชิงสัมพันธ์
4. ไฟล์ Driver มีขนาดเล็กกะทัดรัด
5. สามารถใช้งานได้ทั้ง สถาปัตยกรรม แบบ Two-Tier และ Three-Tier
6. สามารถใช้งานได้หลายระบบปฏิบัติการ
7. เป็น low-level InterFace และสามารถใช้ High-level interface ด้วยถ้าต้องการ
8. การใช้งานจะเป็นเชิง Object-Oriented
9. Driver แต่ละตัวมีมาตรฐานใกล้เคียงกัน


การทำงานที่สำคัญของ JDBC
1. ทำการติดต่อกับ Data Base
2. สั่งคำสั่ง SQL ไปยัง Data Base
3. การับผลลัพธ์จากการใช้คำสั่ง SQL แล้วทำการประมวลผล
ตัวอย่าง นี้เป็นโปรแกรมที่ตัดมา เพื่อแสดงการทำงานทั้ง3 อย่างข้างต้น ดังนี้
Connection con = DriverManager.getConnection( "jdbc:odbc:wombat", "login", "password"); Statement stmt = con.createStatement(); ResultSet rs = stmt.executeQuery("SELECTa, b, c FROM Table1"); while (rs.next()) { int x = getInt("a"); String s = getString("b"); float f = getFloat("c"); }


การรักษาความปลอดภัยของ JDBC ผู้พัฒนา JDBC นั้นควรจะพิจารณา
Ø ความน่าเชื่อถือของโปรแกรม
Ø ความน่าเชื่อถึงของ Java program เป็นไปตาม Java application และ Java appletsจากแหล่งข้อมูลที่เกี่ยวข้องนั้นความจะเป็นserver ที่เก็บรายละเอียดของการให้บริการของบริษัทของคุณหรือ Server หลักApplet สามารถที่จะถูกกำหนดด้วยรหัสลับที่แน่ใจได้ว่าสามารถที่จะdownload ได้อย่างสมบูรณ์
Ø ความไม่น่าเชื่อถึงของโปรแกรม
Ø ความไม่น่าเชื่อถือของโปรแกรมนั้นคือJava Applet ที่เข้า๔งได้ทาง Internet ความไม่น่าเชื่อถือของ Applet คือจะต้องไม่ยอมให Client เข้าถึงเช่นfliesystem ได้เป็นต้น ในอนาคต ความไม่น่าเชื่อถือของ Applet เป็นเพียงแค่การยอมรับการเชื่อมโยงได้กับ network กลับไปยังServer จากการ download


การเปรียบเทียบระหว่าง JDBC และ ODBC
Microsoft ODBC API สามารถใช้ Application ในการติดต่อกับ DataBase ได้เกือบทุกประเภทเช่นกัน มีคำถามว่าทำไมไม่ใช้ ODBC ในการติดต่อฐานข้อมูลในภาษา Java ซึ่งคำตอบก็คือ สามารถใช้ ODBC ในการติดต่อฐานข้อมูลกับ Java ได้ แต่จะเป็นการดีถ้ามีการใช้ JDBC-ODBC Bridge ซึ่งเป็นรูปแบบหนึ่งของ JDBC ซึ่งสามารถสรุปคำตอบคำถามนี้ได้ว่า
1. ODBC ไม่มีความสะดวกในการใช้งานได้โดยตรงจาก Java เพราะมีการใช้ C Interface ในการเรียกคำสั่งจาก Java แล้วแปลงเป็น code ภาษา C มีผลกระทบหลายเรื่อง เช่น Security implement,robustness ของ Application
2. ตัวแปรที่มีการแปลงจาก ODBC (API ไปเป็น Java API จะทำให้เกิดปัญหาขึ้น เช่น Java ไม่มี Pointer ในขณะที่ C มีการใช้งาน Pointer
3. ODBC ยากต่อการเรียนรู้ เพราะมีการผสมผสานคุณสมบัติง่าย ๆ และยาก ๆ เข้าไว้ด้วยกัน และมีการนำเอา option ต่าง ๆ มารวบรวมกันไว้โดยที่เราต้องศึกษา object ทั้งหมด ของ ODBC เพื่อที่ใช้คุณสมบัติแยกย่อยต่าง ๆ ไป แต่ JDBC มีการออกแบบมาทเพื่อการใช้งานให้ได้ง่าย จะมี option ต่างหากเพื่อใช้ในงานที่ยากต่างหาก ซึ่งอยู่ในส่วนของ Advanced Programmer จะต้องศึกษาต่อไปไป
4. Java และ JDBC จะมีการใช้งานร่วมกันได้เพราะต่างก็เขียนขึ้นมาด้วย Code ภาษา Java ซึ่งต่างจาก ODBC การจัดการ ODBC Driver ต้องมีการ ติดตั้งลงในทุก ๆ เครื่องที่มีการใช้งาน ในขณะที่ JDBC Driver มีการเขียนขึ้น ใน code ภาษา Java JDBC code จะถูกรวมอยู่ใน Application โดยอัตโนมัติ ซึ่งจะมีความปลอดภัยกับข้อมูลในการใช้งานในระบบ Network


สถาปัตยกรรมแบบ Two-Tier และ Three-Tier
JDBC สามารถเข้าถึงฐานข้อมูลทั้งแบบ Two - Tier และ Three - Tier ได้ถึงแม้จะใช้ระบบปฏิบัติการที่แตกต่างกันในการทำงานร่วมกัน
- Two Tier ModelJava applet หรือ Application สามารถติดต่อฐานข้อมูลได้โดยตรง ซึ่งมีความต้องการที่จะใช้ JDBC Driver ที่จะสามารถติดต่อกับระบบ DBMS ได้ ซึ่ง User สามารถสั่งคำสั่ง SQL ไปยัง Database และผลลัพธ์ที่ได้ก็จะถูกส่งกลับมายัง user ได้ซึ่ง Database และผลลัพธ์ผลลัพธ์ที่ได้ก็จะถูกส่งกลับมายัง user ได้ซึ่งฐานข้อมูล อาจจะอยู่คนละเครื่องกันกับ Application ซึ่งจะคล้ายการทำงานตามหลักของ Client/Server ซึ่งในขณะเครื่องที่ Application ทำงานอยู่เรียกว่า Client เครื่องที่เป็นDataBase จะเป็น Server,Network จะเป็น Internet ก็ได้
- Three Tier Modelคำสั่งจะถูกส่งไปยัง Middle-Tier ซึ่ง Middle-Tier จะส่งคำสั่ง SQL ไปยัง Data Base อีกครั้งหนึ่ง เมื่อมีการประมวลคำสั่ง SQL แล้วจะมีการสั่งผลลัพธ์กลับมายัง Middle-Tier จาก Middle-Tier จึงสั่งผลลัพธ์มายัง user อีกครั้งหนึ่ง ซึ่ง Middle Tier นี้สามารถจัดการคำสั่งควบคุมในการไป ประมวลผลข้อมูลมาเก็บไว้และแจกจ่ายไปยัง User ต่างๆ เมื่อมีการร้องขอใช้งาน อีกอย่างที่สำคัญคือ การทำงานที่ Middle-Tier นี้จะช่วยให้ง่ายต่อการใช้งานแบบ user-friendly มากที่สุด



ประเภทของ JDBC Driver
1. JDBC - ODBC Bridge
2. Native API partly-Java Driver
3. JDBC-Net Java Driver
4. Native-protocal pure Java Driver


1. JDBC-ODBC Bridge plus ODBC Driver เป็น Driver ของ JDBC ที่ใช้ในการติดต่อการทำงานผ่าน ODBC ซึ่งจะมีการใช้ ODBC ในการติดต่อกับฐานข้อมูลก่อนไม่ว่าจะเป็นในเครื่องเดียวกันหรือติดต่อผ่าน Server แล้วจึงใช้ JDBC ไปติดต่อกับ ODBC อีกครั้งหนึ่ง
2. Native-API partly-Java Driver สำหรับ Driver ประเภทนี้จะเปลี่ยน JDBC calls ไปเรียก Client API ของ Oracle ,Sysbase หรือ DBMS ตัวอื่น ๆ ซึ่งจะคล้ายสะพานเชื่อมต่อไปยัง ฐานข้อมูลอีก
3. JDBC-Net pure Java Driver: Driver ประเภทนี้จะเปลี่ยน JDBC calls ไปยัง DBMS - independent net protocal ซึ่งหลังจากการเปลี่ยนไปเป็น DBMS Protocal โดย Server ซึ่ง Server ตัวนี้สามารถติดต่อเข้ากับ Java Client ไปยัง Database หลายประเภทได้ซึ่งจะสามารถใช้งานผ่านทาง Internet และ Intranet
4. Native-protocal pure Java Driver : Driver ประเภทนี้จะเปลี่ยน JDBC call ไปเป็น network protocal ซึ่งจะถูกใช้โดย DBMS ซึ่งจะมีการใช้งานโดยมีการเรียกใช้งานโดยตรงจาก client ไปยัง DBMS Server
การใช้งาน JDBC การตั้งชื่อฐานข้อมูลบน Network
Javasoft นั้นออกแบบการใช้งานมาตรฐานการตั้งชื่อไว้เป็นแบบURL (Uniform Resource Locator) syntex พื้นฐานที่จะอธิบายถึฐานข้อมูลก็คือ jdbc:: ตัวอย่างฐานข้อมูล mydatabase บนhost cc2.cpe.ku.ac.th ,port 1234 ,โดยใช้ mSQL สำหรับการเข้าถึงทางNetworkjdbc:mSQL://cc2.cpe.ku.ac.th:1234/mydatabase
การประมวลผลการค้นหาข้อมูลและการได้มาซึ่งผลลัพท์ เมื่อได้ผลของการค้นหาข้อมูลโดยSQL จากการทำงานของ java.sql.Statementclass แล้วหลังจากการสถาปนาการเชื่อมโยงฐานข้อมูลจึงสร้างstatement และประมวลผลjava.sql.Statement stmt = conn.creatStatement();ResultSet r = stmt.executeQuery("SELECT a,b,c FROM Table1");ResultSet object r จะได้รับของมูลจากการค้นหาไว้ การกำหนดค่าให้จากfield ใน r โดยใช้ JDBC getxxxwhile (r.next){ int I = r.getInt("a");String s = r.getString("b");byte b[] = r.getByte("c");System.out.println("ROW = "+ I + " " + s + " " + b[0]);}
การใช้งาน แอพพลิเคชั่นเมื่อทำงานในระบบ ไคลเอนท์/เซอฟเวอร์นั้นสามารถเลือกใช้ได้หลายรูปแบบขึ้น อยู่กับลักษณะเฉพาะของงานแต่ละชนิดและขนาดของงานที่เลือกใช้ งานบางชนิดต้องติดต่อฐานข้อมูลขนาดใหญ่ แต่บางชนิดไม่จำเป็นต้องใช้ฐานข้อมูลขนาดใหญ่มานัก องค์ประกอบเหล่านี้มีส่วนเกี่ยวข้อง กับประสิทธิภาพของแอพพลิเคชั่นและผลลัพธ์ของงานที่ได้มา มีวิธีการแก้ปัญหาโดยแบ่งแอพพลิเคชั่น ออกเป็นโมดูลย่อย ให้ทำงานร่วมกัน แต่ละโมดูลทำงานตามหน้าที่ของตนเป็นอิสระจากโมดูลอื่นทำให้ง่าย ต่อการเปลี่ยนแปลงแก้ไขและบำรุงรักษา เรียกการทำงานแบบนี้ว่า " มัลติเทียร์" ซึ่ง พัฒนามาจาก "ทู-เทียร์" และใช้วิธีการเข้าถึงฐานข้อมูลโดยใช้ JDBCไดรเวอร์ ( Java Database Connectivity Driver ) ซึ่งแบ่งตามลักษณะการทำงานออกได้เป็น 4 แบบ ขึ้นอยู่กับว่าผู้ใช้จะเลือก


Top Ten Oracle JDBC Tips 10 tips ในการใช้ JDBC กับ Oracle ดังนี้
1. ใช้ JDBC Thin Driver ในการติดต่อ Oracle โดยตัว Thin driver นี้จะถูกสร้างด้วยภาษา java 100% และมีความเร็วในการทำงานมากกว่า OCI แต่ทาง Oracle ก้ยังแนะนำให้ใช้ OCI มากกว่า
2. กำหนดให้ auto-commit ของ connection ให้เป้น false เสมอ เพื่อประสิทะภาพการทำงานที่ดีกว่า
connection.setAutoCommit( false );
แต่จะต้องระวังการใช้งาน ซึ่งจะต้องใช้คู่กับ commit/rollback เสมอนะครับ
3. ใช้ Statement object กับ dynamic SQL statementเสมอ
4. ควรจะมี hellprt method/class สำหรับการจัดการ dynamic SQL statement เสมอ เช่นการจัดการเกี่ยวกับ escaping characters
5. ควรจะใช้ PreparedStatement Object เสมอ ยกเว้นกับ dynamic SQL statement เนื่องจากตัว preparedstatement object นี้มีความเร็วในการทำงานมากกว่า Statement object รวมทั้งยังช่วยจัดการปัญหาของ SQL Injection อีกด้วย
6. ควรที่จะใช้ PreparedStatement object ร่วมกับ Baching task ในการ Insert, Update ข้อมูลจำนวนมากๆ ซึ่งจะทำงานเหมือนการ run bacting process
7. ควรใช้ Oracle Locator method ในการ insert, update, select LOBs ( Large Objects )
8. SQL92 or Oracle PL/SQL block syntax ในการเรียกใช้ Store Procedure
9. ควรจะใช้ Object SQL ในการ transfer ข้อมูลจาก Java Object ( Value Object ) ไปยัง Table ใน Database
10. ควรที่จะทำการ tunning SQL Statement เสมอ