เพราะว่า servlet เป็นโปรแกรมจาวา
>> เพราะว่า servlet เขียนด้วยภาษาจาวา สร้างขึ้นมาเพื่อเป็น server side programs ที่ต้องทำงานภายใต้สภาวะแวดล้อมของ Servlet Container
>> Servlet Container เป็น component ประเภทหนึ่งของโปรแกรม web server ซึ่งทำงานบนโปรโตคอล HTTP พูดง่ายๆว่า Servlet Container เป็นผู้จัดการ servlet ผ่าน interface ที่ชื่อ Servlet ด้วยเหตุนี้มันจึงสามารถควบคุมจัดการ servlet ทุกตัวได้โดยละม่อม
>> จากตัวอย่างที่ 1 (example1) ภายใต้ folder
D:\training\example1\src\training\controller
คลาส HelloServlet ไม่สามารถเป็น servlet ได้หากไม่ implements เจ้า interface ที่ชื่อ Servlet แล้ว interface ที่ว่าอยู่ไหน?
>> ดังจะเห็นว่าคลาส HelloServlet ขยายมาจากคลาส HttpServlet พูดง่ายๆว่ามันเป็นลูกของ HttpServlet ส่วน HttpServlet ก็เป็นพ่อมัน เออว่าไป
>> HttpServlet ก็ขยายมาจากคลาส GenericServlet อีกที ซึ่ง GenericServlet นี่แหละครับที่ implements เจ้า interface ที่ชื่อ Servlet ให้
>> คำถามที่มือใหม่อย่างผมสงสัยคือ ก็ถ้าจะเขียนคลาสจาวาธรรมดาให้กลายเป็น servlet ก็แค่ implement Servlet interface ชิมิ คำตอบคือ ใช่ครับ แล้วผมขอสังสัยต่อว่า แล้วจะไป extends คลาส HelloServlet อีกทำไมล่ะ? คำตอบลึกซึ้งนี่ต้องกล่าวถึงโปรแกรม HTTP Server กับ Request Methods ทั้ง 7 ประเภท (part 2) เพราะเราจะให้ servlet ทำงานผ่านทางนี้ (มีทางอื่นอีก แต่ไว้ก่อนนะครับ) นั่นหมายความว่าเมื่อมีคำร้องขอหรือ request เข้ามา โปรแกรม servlet ของเราจะต้องเข้าใจให้ได้ว่าเป็นคำร้องขอประเภทไหน ขอไฟล์ เพิ่มข้อมูล ปรับปรุงข้อมูล หรือลบข้อมูล อะไรอย่างนี้เป็นต้น ถามกลับว่า แล้วง่ายไหมหากรับเอา interface เพียวๆมาจัดการเอง คำตอบชักไม่แน่ใจ เพราะ Servlet interface นั้นว่าด้วยเรื่อง
- void init(ServletConfig config)
- ServletConfig getServletConfig()
- void service(ServletRequest req, ServletResponse res)
- String getServletInfo()
และ void destroy()
แต่ถ้ารับสืบทอดหรือขยายคลาสมาจาก HttpServlet จะว่าด้วยเรื่อง
- doGet ทำอะไรดีนะ
- doPost ทำอะไรดีนะ
เป็นต้น ซึ่งชัดเจนที่ประเภทคำร้องขอมากกว่า ไหนยังจะมี GenericServlet เป็นพ่อแม่ช่วยจัดการ config ไฟล์ web.xml ในโปรเจ็กต์ผ่าน interface ที่ชื่อ ServletConfig ให้อีกด้วยนะเออ
>> สรุป HelloServlet extends HttpServlet น่ะดีแล้ว
>> ตัวอย่างแรกนี้พี่เขา override เมธอด doGet ให้ servlet ของเราสร้างหน้าเอกสาร HTML ง่ายๆขึ้นมา มีแท็ก h1 เขียน Hello Servlet ส่วนแท็ก h2 เขียน TEST ปิดท้ายด้วยการทดสอบเรียกจาวาคลาส Date โชว์วันและเวลาครับ
>> ตอนนี้ให้สงสัยไว้ก่อนว่า
- doGet ทำงานได้อย่างไร?
- HttpServletRequest request คืออะไร มาจากไหน?
- HttpServletResponse response คืออะไร มาจากไหน?
เป็นว่าถ้าเราต้องการสร้างเอกสาร HTML ส่งกลับไปยัง browser หรือก็คือผู้ร้องขอต้นทาง ให้ใช้ออบเจ็กต์ PrintWriter ซึ่งขอได้จาก response เป็นผู้สร้างให้นะครับ
>> part นี้จบเท่านี้ก่อน เยอะแล้วจะไม่อยากอ่านต่อ อิอิ สวัสดีครับ
มาทำความเข้าใจ Ant กันสักหน่อยดีไหม
>> ประโยชน์ของการเขียนบันทึกแบบนี้ผมได้อะไร? ได้ทบทวนสิ่งที่ยังไม่ชอบให้พยายามชอบให้ได้ สิ่งที่ยังไม่รู้ให้พอรู้บ้าง ทั้งยังได้ update บล็อคฝึกหัดของตัวเองด้วยครับ
>> ทำไมมาพูดเรื่อง Ant ใน Servlet? เพราะอยากเข้าใจมันมากกว่ามารันคำสั่ง ant deploy เฉยๆครับ ตรงๆคือไม่รู้อะไรเกี่ยวกับ Ant เลยในตอนนี้ พี่เขาเขียนมาให้จึงต้องการทราบว่ามันทำงานอย่างไร ว่าแล้วก็ไปดูกัน
>> Apache Ant ที่ได้ติดตั้งไปคืออะไร? คือเครื่องมือสำหรับใช้ build ภาษาจาวา โดยบริษัทของคนอเมริกันที่ให้การสนับสนุนโครงการ Apache software ซึ่งไม่หวังผลกำไร, Ant นี้ย่อมาจาก Another Neat Tool ครับ
>> ทำอะไรได้บ้าง? งานส่วนใหญ่เกี่ยวกับจาวาที่นักพัฒนามักทำได้แก่
- คอมไพล์โค้ด
- แพ็คโค้ดเป็น jar หรือเป็น war
- เอามันขึ้น server
- ทดสอบการทำงาน
- คัดลอกโค้ดจากที่หนึ่งไปที่หนึ่ง
เหล่านี้ Ant ช่วยได้หมด โดยสั่งมันที่ command line
>> โหลด Ant ต้องทำไง? ไปที่นี่เลย
http://ant.apache.org/
แล้วมองหาประโยคว่า download as source or binary from คลิกลิงค์โหลด แล้วเลือกที่เป็น .zip ใครที่ทำไปแล้วตั้งแต่ part ก่อนก็ไม่ต้องทำนะ
>> ติดตั้ง Ant ต้องทำไง? เริ่มจาก
- กำหนดตัวแปร JAVA_HOME ให้ระบบรู้จักที่ที่เราได้ติดตั้ง JDK ลงไป
- กำหนดตัวแปร ANT_HOME ให้ระบบรู้จักที่ที่เราแตก .zip ไฟล์ของ Ant ที่ดาวน์โหลดมา ของผมคือ
C:\apache-ant-1.9.4
>> หมายเหตุ เอ๋ จำได้ว่าคราวก่อนเซตไว้กับตัวแปร PATH นี่หว่า ขออนุญาตไปคัดลอกออกมาแล้วกำหนดให้ ANT_HOME ก่อนนะ ส่วนที่เขียนไว้กับตัวแปร PATH ก็ยังคงต้องระบุเป็นแบบนี้
C:\Program Files\Java\jdk1.7.0_75\bin;%ANT_HOME%\bin
>> ทดสอบยังไงว่า Ant ทำงานได้? ด้วยการพิมพ์
ant -version ที่ command line
>> อย่างที่ทราบ Ant จะทำหน้าที่ build ไฟล์ โดยต้องตั้งชื่อไฟล์ว่า build.xml ซึ่งตอนนี้เรายังไม่มี ก็ให้สร้างมันขึ้นมาด้วยโปรแกรมเขียน text file ที่มี (ไส้ในของมันเป็น text ที่มีโครงสร้างสร้างด้วยแท็ก XML ครับ) ส่วนผมใช้ Sublime ใส่รายละเอียดลงไปตามนี้
<?xml version="1.0"?>
<project name="Hello World" default="info">
<target name="info">
<echo>Hello, I am Ant!</echo>
</target>
</project>
บรรทัดแรกสุดห้ามเว้นช่องว่างหรือขึ้นบรรทัดใหม่เด็ดขาดนะครับ ตอน build จะ error ได้ ให้เขียนชิดติดมุมซ้ายบนเลย
ผมเขียนแล้วบันทึกชื่อไฟล์ว่า build.xml ไว้ ณ D:\ant
>> รันมันอย่างไรล่ะ? ง่ายๆให้เปิด command line จากนั้นชี้เป้าไปที่ D:\ant พิมพ์คำสั่ง ant เฉยๆ มันจะหาและจัดการ build ไฟล์ที่เราได้สร้างไว้เองครับ จะได้ผลลัพธ์เป็น
info: [echo] Hello, I am Ant!
>> ในแท็กข้างต้นประกอบด้วยอะไรบ้าง? ครับผม
- name เป็นชื่อ project ไม่ใส่ก็ได้
- default กำหนด target แท็กที่ต้องจัดการ (build) ในระดับ default (หากว่าเราพิมพ์คำสั่ง ant เฉยๆไงล่ะ) ซึ่งต้องระบุเสมอนะครับ ในตัวอย่างก็คือ target ชื่อ info
- target ก็คือแท็กงานที่จะต้องถูกจัดการ ในที่นี้เราให้มันแสดงข้อความ Hello, I am Ant!
>> ตอนนี้เราก็ได้เริ่มต้นแล้ว ถ้าเพื่อนๆสนใจศึกษาต่อ ตามตัวอย่างที่ผมยกมา ที่นี่เลยนะ
http://www.tutorialspoint.com/ant/index.htm
>> อ่านเกี่ยวกับวิธีการเซตตัวแปร ANT_HOME จาก Oracle
https://docs.oracle.com/cd/E19575-01/820-7054/gicjc/index.html
>> โอกาสต่อไปเราไปลุย Servlet กันต่อ ว่าด้วยรายละเอียดของมัน คืนนี้สวัสดีครับ
สิ่งที่อาจารย์ผมมักบอก จาวานั้นต้องเข้าใจความคิด OOP
>> นานหนักหนาแล้วที่ผมไม่ได้ทบทวนหลักการนี้เลย ให้งานและสถานการณ์สานต่อถ่ายเดียว เขียนโปรแกรมก็คิดเป็นโปรแกรม มิได้เงยมองขึ้นมาหาความจริงที่ว่า OOP คือแนวคิดล้อเลียนชีวิต อย่างไรมาดูกันครับ
1) คลาส ก็คือ นิยาม การนิยามมีสองแบบ เขานิยามให้ กับ เรานิยามเอง, เขานิยามให้ก็คือคลาสไลบรารี่จัดเตรียมมาให้ ภาษาจาวาจัดเตรียมให้ใช้ ส่วนเรานิยามเองคือเราเขียนเอง วางจุดมุ่งหมายและออกแบบเอง
2) คลาส ก็คือ ไทป์ หรือก็คือชนิดของตัวแปรตามการนิยามข้างต้น ภาษาจาวาประกอบไปด้วยไทป์มากมาย คุ้นๆเช่น int double float String วันนี้สร้างเอง เช่น Dog Student เป็นต้น
3) คลาส ก็คือ พิมพ์เขียว แม่แบบของวัตถุหรือแม่แบบของออบเจ็กต์นั่นแหละ มีคลาสจึงสร้างออบเจ็กต์ได้ และสร้างผ่านตัวสร้างที่เรียกว่า คอนสตรัคเตอร์
4) คอนสตรัคเตอร์ มีหน้าที่จัดเตรียมวัตถุหรือออบเจ็กต์ให้พร้อมใช้งานอย่างสมบูรณ์ที่สุด เพื่อที่หลังจากนี้ ชีวิตของพวกมัน (วัตถุหรือออบเจ็กต์เหล่านั้น) จะต้องดำเนินไปจนกว่าจะตาย (เซตค่าให้เป็น null)
5) Encapsulation คือความคิดเพื่อจัดการการเข้าถึงข้อมูล มักใช้ควบคู่กับความคิดในการซ่อนข้อมูล (information hiding) เมื่อเกิดการซ่อนข้อมูลเนื่องจากข้อมูลนั้นอ่อนไหวหรือเป็นสิ่งสำคัญ การเข้าถึงข้อมูลก็จะถูกจำกัดไว้เพียงในคลาส ทว่ายังมีข้อมูลบางอย่างที่จำเป็นต้องถูกเรียกใช้ภายนอกคลาสหรือแม้แต่ส่งต่อไปยังคลาสลูก จึงต้องมีวิธีในการเข้าใช้หรือเข้าถึงข้อมูลนั้นตามมา (encapsulation) สำหรับภาษาจาวา ระดับการเข้าใช้หรือเข้าถึงข้อมูลดังกล่าวได้แก่ private, protected, package (default) และ public ครับ
6) Inheritance คือแนวคิดเพื่อการขยาย (extends : เติม s เพราะประธานเป็นเอกพจน์บุรุษที่สาม) ให้มีคุณสมบัติและความสามารถตั้งแต่อดีตจนถึงปัจจุบัน เป็นแนวคิดที่ทำให้เกิดกระบวนการค้นหา (pursuance) ตามหาสิ่งที่เป็นของผู้ถ่ายทอด (มักเรียกคลาสพ่อหรือคลาสแม่) ตลอดจนคลาสบรรพบุรุษที่ได้ขยายมาทั้งหมด ผมชอบตัวอย่างนี้มาก เมื่อเทียบว่าการ inheritance คือการถ่ายถอดหรือสืบทอดแบบลูกได้รับจากพ่อแม่ นั่นหมายความว่าพ่อแม่คลาสกระทั่งปู่ย่าตายายคลาสสามารถฟื้นคืนชีพได้ เพียงแค่มีคลาสรุ่นหลานเกิดขึ้น (ถูก new) ประดาผู้ส่งต่อทั้งหลายจะถูกเรียกให้มีชีวิตด้วยตลอดสายการสืบทอดนั้นๆ พอเข้าใจแล้วสยองมาก
7) Polymorphism คือแนวคิดให้คลาสมีรูปแบบ (form) หรือขั้นตอน (stage) อันหลากหลายไม่ว่าจะในทางสืบทอด (extends) หรือไม่ก็ตาม
- ในทางสืบทอด เช่น การ override เมธอดของคลาสพ่อแม่ การระบุคุณลักษณะทั่วไปหรือที่เรียกกันว่า interface เป็นต้น
- ส่วนในทางไม่สืบทอด เช่น การทำ method overloading ให้รับพารามิเตอร์ต่างชนิด ต่างจำนวน เพื่อทำงานอย่างเดียวกัน, การ override เมธอดของคลาสเพื่อให้เกิดการทำงานที่ต่างจากเดิมโดยไม่มีกระบวนการสืบทอด เป็นต้น
8) Interface หรือคุณลักษณะทั่วไปที่จำกัดบทบาทของคลาส หรือใช้นิยามบทบาทของคลาสให้สามารถทำสิ่งใดๆได้บ้าง เพื่อให้ไทป์มีความยืดหยุ่น ทำให้เกิดกระบวนการค้นหาหรือตามหาสมบัติแท้จริงของออบเจ็กต์ในขณะ run time ได้ ยกตัวอย่างง่ายๆ ให้ผู้ชายฉี่ได้ ผู้หญิงฉี่ได้ เมื่อคลาสผู้ชายรับเอา interface ไปฉี่ ผู้ชายก็จะไปยืนฉี่ เมื่อคลาสผู้หญิงรับเอา interface ไปฉี่ ผู้หญิงก็จะไปนั่งฉี่ เป็นต้น (ตัวอย่างนี้ผมคิดเอง ขออภัยที่ต่ำทราม แต่คิดว่าคงเห็นภาพกันชัดเจน คือฉี่ได้ทั้งผู้ชายและผู้หญิง แต่จะฉี่อย่างไรก็ขึ้นอยู่กับคลาสนั้นๆจะเลือกกระทำ)
>> จะเห็นว่าเรื่องราวของออบเจ็กต์มี เกิด (constructor) มีใช้ชีวิต (พฤติกรรมหรือบริการ) และตาย (สิ้นอายุโดยขอบเขตใดๆหรือถูกเซตค่าเป็น null) และเป็นเรื่องราวที่น่าสนุก เสียดายก็แต่เวลาศึกษาเรื่องพวกนี้กลับนำไปใช้ในเรื่องอื่น ความเข้าใจต้องได้รับการต่อยอด ความต่อเนื่องจึงเป็นสิ่งสำคัญที่ขาดไม่ได้ ขอบคุณมากครับพี่ ขอบคุณสาวสวยที่มาเรียนด้วยกัน ขอบคุณครับ
Hello Servlet โปรแกรมแรก
>> ติดตั้ง JDK เซตตัวแปร PATH ให้ชี้ไป ณ ...\Java\jdk1.8.0_31\bin (แล้วแต่ว่าแต่ละคนติดตั้งไว้ที่ไหน) เพื่อให้ระบบปฏิบัติการมองเห็น javac.exe และ java.exe เพราะ javac.exe ใช้คอมไพล์ไฟล์ .java เป็น .class ส่วน java.exe ใช้รันไฟล์ .class โดยการพิมพ์คำสั่ง javac ที่ command line ว่ามองเห็น javac หรือไม่
>> ติดตั้ง Apache Tomcat เป็น server อันที่จริงไม่เรียกว่าติดตั้ง เพราะแตก .zip ก็ใช้งานได้เลย ผมวางมันไว้ ณ C:\apache-tomcat-8.0.14 อย่าลืมเซตตัวแปร CATALINA_HOME ให้ชี้ไป ณ folder ข้างต้น เพื่อให้เรา start server ได้ โดยการพิมพ์คำสั่ง C:\apache-tomcat-8.0.14\bin>startup.bat ที่ command line
>> เนื่องจากพี่เขาเขียน Ant มาให้ (โปรเจ้กต์ของเราเป็น java web) เราจะใช้มัน deploy แต่ละตัวอย่างไปวางไว้บน server ทั้งนี้เพื่อตัดขึ้นตอนการ
- ตรวจสอบไวยากรณ์
- การคอมไฟล์
- การ packaging
- การ deploy (วาง .war ลงไปยัง server)
เพียงเซตตัวแปร JAVA_HOME ให้ชี้ไป ณ ...\Java\jdk1.8.0_31 (แล้วแต่ว่าแต่ละคนติดตั้งไว้ที่ไหน) อย่าลืมบอก PATH ให้รู้จัก Ant ด้วย ด้วยการกำหนดไปยัง C:\apache-ant-1.9.4\bin
>> สองคำสั่งเกี่ยวกับ Ant ที่ต้องทราบ เมื่อต้องการ deploy แต่ละตัวอย่างไปยัง server ให้แต่ละตัวอย่างวางอยู่ ณ D:\training ในที่นี้จะ deploy ตัวอย่างที่ 1 ซึ่งเส้นทางการเข้าถึงคือ D:\training\example1
- พิมพ์ ant deploy สำหรับ built และวาง .war ไปยัง server
- พิมพ์ ant undeploy สำหรับลบ .war นั้นออกจาก server (ไม่แน่ใจว่าใช้คำว่าลบถูกต้องไหมนะ)
>> สรุปเราต้องทำอะไรบ้าง หลังจาก download โปรเจ็กต์ตัวอย่างด้านล่างนี้ไป
1) set ตัวแปร PATH ให้กับระบบ ชี้ไปที่
C:\Program Files\Java\jdk1.8.0_31\bin;
C:\apache-ant-1.9.4\bin
2) set ตัวแปร CATALINA_HOME ให้กับระบบ ชี้ไปที่
C:\apache-tomcat-8.0.14
3) set ตัวแปร JAVA_HOME ให้กับระบบ ชี้ไปที่
C:\Program Files\Java\jdk1.8.0_31
4) เข้าไปยังโปรเจ็กต์ที่ต้องการรันโดย command line ของผมคือ
D:\training\example1
5) พิมพ์ ant deploy (หาก fail เพราะมีโปรเจ็กต์นั้นๆอยู่แล้วบน server ให้พิมพ์ ant undeploy ก่อนครับจะได้ deploy ซ้ำได้)
ดาวโหลด์
- Apache Tomcat: https://tomcat.apache.org/ มองหาคำว่า download
- Apache Ant: http://ant.apache.org/ มองหาคำว่า download
- ตัวอย่างโปรเจ็กต์: http://www.mediafire.com/download/6r9535oerr86bay/training.rar
6) เปิด browser จากนั้นพิมพ์
http://localhost:8080/servlet/s1
>> รายละเอียดปลียย่อยมากกว่านี้ ขออนุญาตเล่าเพิ่มเติม ณ part ต่อๆไป คืนนี้ฝันดีครับ
status code พื้นฐานที่ควรทราบ
>> เอาล่ะครับ หนก่อนกล่าวถึง HTTP หรือเส้นทางพูดคุยระหว่าง client กับ server เรารู้แล้วว่า client ติดต่อ server เรียกว่า request และ server ติดต่อ client เรียกว่า response แลก่อนจะเข้าเรื่อง servlet เราควรทำความเข้าใจรายละเอียดของสองสิ่งนี้สักเล็กน้อย
>> request มีอยู่ 7 ประเภท
1) GET สำหรับร้องขอ resource (เว็บเพจ, รูปภาพ เป็นต้น)
2) HEAD เหมือน GET เลย แต่มีมาให้เฉพาะส่วนหัวของไฟล์ เรียกว่า header ที่ส่งกลับมา
3) PUT สำหรับ upload ไฟล์ไปเก็บไว้ที่ server
4) POST เหมือน GET แต่จะหนีบเอาคู่ key-value จาก form ไปด้วย และไม่แสดงรายละเอียดของ URL บน address bar
5) DELETE สำหรับลบไฟล์ออกจากปลายทางที่ระบุ
6) OPTIONS สำหรับร้องขอประเภทของ request จาก server ว่าสนับสนุน request ประเภทไหนบ้าง
และ 7) TRACE สำหรับดึงค่า request ที่เราได้ส่งไปยัง server กลับมา (โอ้สุดยอดมาก)
>> พูดคำว่า URL ก็เยอะ แล้วมันคืออะไร? URL ย่อมาจาก Uniform Resource Locator หรือ Universal Resource Locator ใช้สำหรับระบุแหล่งที่อยู่ของทรัพยากร (resource) ที่ต้องการ ประกอบไปด้วย
1) ชื่อโปรโตคอลที่ใช้ เช่น http หรือ https เป็นต้น
2) ชื่อเครื่องคอมพิวเตอร์และเครือข่ายย่อย แท้จริงคือชุดตัวเลขที่มีจุดคั่น และมักถูกผูกเป็นชื่อเพื่อให้เรียกง่ายขึ้น เช่น www.facebook
3) ประเภทของเวบไซต์ บ้างก็เรียกว่าสกุลของเว็บที่จดทะเบียน เช่น .com .co.th หรือ .net เป็นต้น (เมื่อนำข้อสองและสามมารวมกันจะเรียกว่า ชื่อโดเมน)
5) ไดเร็กทอรี่ ง่ายๆคือชั้นของ folder ที่ซ้อนกันเป็นชั้นๆ คั่นด้วยเครื่องหมาย /
6) ชื่อไฟล์และนามสกุล หรือก็คือตัว resource ที่เราต้องการ เช่น my_image.png หรือ index.html เป็นต้น
>> แล้ว URI ล่ะ? มันย่อมาจาก Uniform Resource Identifier พี่เขาใช้คำว่า พ่อของทุกสถาบัน หมายถึง การระบุไปยังปลายทางถึงระดับ identifier ซึ่งละเอียดกว่า URL ทว่าในทางปฏิบัติต่อเรื่องนี้ URL ก็เพียงพอแล้วครับ
>> สุดท้ายคือ response ประกอบด้วยสามส่วนใหญ่ๆ
1) ผลลัพธ์จากการพยายามประมวลผล request ที่ร้องขอเข้ามา ได้แก่
- version เช่น HTTP/1.1
- status code เช่น 200
- description เช่น OK ค่ะ
2) response header รายละเอียดคล้ายกับ request header (HEAD)
3) response body เป็นรายละเอียดของสิ่งที่ต้องส่งกลับไปยัง client เช่นหน้าเพจที่บอกว่า คุณสมัครสมาชิกเรียบร้อยแล้ว คุณจ่ายเงินเรียบร้อยแล้ว หรือ สวัสดีฉันชื่อ server นะจ๊ะไรงี้
>> อ้อ สุดท้ายของสุดท้ายของ part นี้ เมินเฉยไม่ได้กับ status code สถานะต่างๆ เช่น
- 1XX แสดงข้อมูลต่างๆ
- 2XX บอกว่าคำร้องสำเร็จ เย้!
- 3XX บอกว่า redirect (การส่งต่อ) ไปยัง URL อื่น (เหมือนบางเว็บที่ท่านๆชอบกัน จะ redirect อย่าหนักหน่วง เพื่อหนีกระทรวงที่เคยเป็นข่าวแปะลิงค์โป๊)
- 4XX เกิด error จ้า แต่เป็น error จาก client (ทำนองว่าโดน server ด่า)
- 5XX เกิด error จ้า แต่เป็น error จาก server (ได้ทีเราด่ากลับม่าง)
>> ที่เจอบ่อยๆขณะเพิ่งหัดเขียนเว็บก็คือ 404 Not Found หาไฟล์ไม่พบ เป็นความผิดของเราที่แจ้ง resource ที่ต้องการผิดพลาด และ 500 Internal Server Error คือมีปัญหาอะไรสักอย่างที่ server เช่น package pl/sql พังทลาย (เยเย้ ไม่ต้องทำงาน) เป็นต้น ส่วนถ้าเจอ 503 Service Unavailable นี่ให้ใจเย็นๆครับ เดี๋ยวเว็บเกมออนไลน์นั่นก็กลับมาใช้ได้
>> คืนนี้ดึกแล้ว พักผ่อนรอ part ต่อไป (เมื่อไรจะได้เขียนแว้) ขออนุญาตไปทักทายยอดดวงใจก่อน สวัสดีครับผม
โครงการ servlet ปันน้ำใจจากพี่สู่น้อง
>> จากโครงการเรียน servlet ช่วยน้องที่ผ่านมา ต้องขอบคุณพี่แม็กมากๆที่ช่วยถ่ายทอดความรู้ให้ตลอดจนแนะนำวิธีการดีๆผ่านประสบการณ์จริง และเพื่อให้มันคงอยู่ต่อไป ผมจึงใคร่บันทึกมันไว้ตามความเข้าใจของตัวเอง โดยขออนุญาตนำ project เล็กๆที่พี่แม็กแสดงเป็นตัวอย่างมาเล่าสู่เพื่อนๆที่สนใจครับ
>> servlet คืออะไร? มันคือโปรแกรมที่เขียนด้วยภาษาจาวา หรือก็คือจาวาคลาสซึ่งมีหน้าที่ประมวลผลคำร้องขอจาก client
>> client คืออะไร? คือเครื่องคอมพิวเตอร์ที่ร้องขอบริการและรับบริการอย่างหนึ่งอย่างใดจาก server
>> server คืออะไร? คือเครื่องคอมพิวเตอร์ที่อาศัยโปแกรม web server ทำหน้าที่รับคำร้องและส่งคำร้องขอนั้นกลับไปยัง client (ความหมายของ server มีมากกว่านี้ แต่ยกมาเท่าที่อยากจะเล่าให้ฟังนะ อิอิ)
>> web server คืออะไร? คือโปรแกรมคอมพิวเตอร์ซึ่งทำหน้าที่ให้บริการข้อมูลแก่ client, พูดให้ชัดๆในเรื่องนี้ web server คือผู้จัดการกับ HTTP request และ HTTP response ครับ เช่น Apache, IIS เป็นต้น
>> HTTP request และ HTTP response คืออะไร? ก่อนอื่นต้องทราบว่า HTTP ย่อมาจาก Hyper Text Transfer Protocol ฟังแล้วง่วงมาก มันถูกประดิษฐ์ขึ้นมาเพื่อขนส่งข้อมูล (ชนิด text) บนระบบโปรโตคอล TCP อีกทีหนึ่ง (ลึกกว่านี้ไม่ทราบแระครับ) ซึ่งโปรโตคอลตัวนี้คือพื้นฐานของระบบเครือข่ายใยแมงมุมที่เรียกกันว่า World Wide Web หรือก็คือระบบ client / server ขนาดโอฬารนั่นเอง ดังนั้น HTTP request ก็คือคำร้องขอผ่านโปรโตคอล HTTP ส่วน HTTP response คือผลลัพธ์ที่ส่งกลับออกไปผ่านโปรโตคอล HTTP ครับผม
>> กลับมาที่ servlet สืบเนื่องจากมันเป็นไฟล์ที่มีนามสกุลเป็น .java ดังนั้นมันจึงต้องถูกคอมไพล์เป็น .class ผ่าน JDK เสมอ คำถามคือ JDK คืออะไร? (ไม่รู้จริงอะ)
>> JDK ย่อมาจาก Java Development Kit ประกอบด้วย JRE, โปรแกรม compiler ภาษาจาวาและ debugger ครับ
>> จะเรียก servlet ให้ทำงานได้อย่างไรล่ะ (java web application)? ได้โดยส่ง HTTP request ไปยัง web server ครับ
>> web server ในศึกนี้ใช้ตัวไหน? เราใช้ Apache Tomcat หรือเจ้าแมวเหลือง นั่นเพราะมันเป็น web container ที่มี web server เล็กๆผูกติดมาให้พร้อมใช้ ก็ถ้าไม่ใช้ Apache Tomcat เราอาจต้องไปหาโปรแกรม web server อื่นมาติดตั้งลงไป อย่างที่บอกไป เช่น IIS web server หรือ Apache web server เป็นต้น
>> แล้ว web container คืออะไร? คือโปรแกรมที่ช่วยประมวลผลไฟล์สคริปต์ใดๆ ไม่ว่าจะเป็น JSP, PHP, ASP.NET และอื่นๆอีกมากมายให้สามารถทำงานตามคำร้องขอที่ส่งเข้ามา และเมื่อพูดถึง Apache Tomcat web container มันจะทำหน้าที่ประมวลผลไฟล์ .jsp หรือพูดให้ชัดๆคือแปลงไฟล์ .jsp ไปเป็น .java ซึ่งไฟล์ .java นี้ก็คือ servlet อิอิอิ
>> ตกลงต้องเขียน JSP (ไฟล์นามสกุล .jsp) ด้วยเหรอ? คำตอบตรงๆคือไม่ครับ หากเราต้องการเพียงสร้าง URL เพื่อเรียก servlet ให้ทำงานแค่นั้น
>> แล้วถ้าต้องการส่งข้อมูลให้ servlet ล่ะ? ก็สร้าง form ขึ้นมาจากภาษา HTML หรือภาษาสคริปต์อื่นๆเช่น JSP, PHP, ASP.NET เป็นต้น ส่วนรายละเอียดจะกล่าว ณ part ต่อๆไป (หรือลืมไปเลย)
>> สรุปว่าจะได้รู้ JSP ด้วยไหม? ตอบว่าแน่นอน แต่เนื้อหาส่วนใหญ่จะเป็น servlet มากกว่า หรือกล่าวว่าเรียน servlet ก็จะได้เรียน JSP ควบคู่กันไป อย่างที่บอกไปแล้ว .jsp ท้ายสุดจะถูกแปลงเป็น .java ที่เรียกว่า servlet
>> และในเมื่อ web container ที่เราพูดถึงจะเปลี่ยน .jsp เป็น servlet ฉะนั้นตัวจัดการ servlet จึงไม่ใช่ web container จริงไหมพี่น้อง ใช่แล้วล่ะ เรามีโปรแกรมที่จัดการ servlet เป็นการเฉพาะซึ่งเราเรียกมันว่า servlet container อิอิอิ
>> ศัพท์เยอะชักเริ่มมึนก็ไม่แปลก คนที่เริ่มเรียน servlet จึงมักงงเป็นไก่ตาเขียวแทบทุกคน เพราะกว่าจะได้ Hello World สมองก็บวมไปหมดแว้ว เจอกัน part หน้าครับ ผิดพลาดตรงไหนบอกด้วยนะครับ ขอบคุณครับผม
>> เรื่องนี้สมชายต้องจัดเต็ม เลิกลูกทุ่งมุ่งสู่อนาคต part 2 (จบ)
>> ต่อจาก if else มหาโหดที่ซ้อนกันเป็นตับเพื่อจัดการกับขนาดหน้าจอที่แตกต่างกันโดยไม่คิดจะใช้เรื่อง web responsive มาแก้ปัญหา และสมชายกับสมปองยังคงนั่งผลิต if else แห่งชะตากรรมต่อไป ส่งผลให้งานไหนก็ตามที่มีเรื่องขนาดจอภาพเข้ามาเกี่ยวจำต้องไปเขียนกระจุกกันตรงนั้น
>> แม้สมปองจะเคยมาอ่านบทความนี้ก็ตาม เธอยังคงคิดว่ามันทำงานได้ก็ให้มันทำงานต่อไป สนใจใช่เรื่อง จะหาเรื่องใส่ตัวทำไมชิมิ จากที่มี 50 บรรทัดผ่านคืนวันอันอบอุ่นก็กลายเป็น 500 บรรทัด และกลายเป็น 5000 บรรทัดในสองปี คราวนี้จะยัดอะไรลงไปก็เริ่มลำบากใจกลัวว่ามันจะไปกระทบกับส่วนอื่นๆ เอ๋หรือเปล่านะ? ส่งผลให้กระบวนการ test ยืดยาวใช่เหตุ ต้องตามมา test ของเก่าค้างปีที่เคยทำงานได้ดีในอดีตชาติ ทั้งๆที่ต้องการใส่ปุ่มกดแค่ปุ่มเดียว หากเป็นปุ๋ยอินทรีย์ต้นไม้คงได้เฮออกดอกออกผล แต่นี่เป็นโค้ดจาวาเพื่อจัดการหน้าตา (interface) หน้าบ้านที่ต้องฉายต่อประชาคมโลก มันจึงไม่ออกดอกผลิผลสักที แต่รอวันยืนต้นตายเท่านั้นเอง (เศร้าใจจริงๆ)
>> สมชายก็เลยปลอบใจสมปองว่า ช่างเถอะ มันมีมานานแล้ว เราทำอะไรไม่ได้หรอก (ห๊ะอะไรนะ?) ทั้งๆที่รู้แก่ใจแล้วแท้ๆสองคนนี้ยังเฉย สมควรถูกเรียกว่ามนุษย์ยุคหิน เออนะ ถ้าไม่รู้นี่ไม่ว่าเลย แล้วถ้าอยากจะแก้ไขล่ะ (ปรบมือ เฮ ดีที่ยังมีความรับผิดชอบ) ผู้รู้เขาบอกมาว่าอย่างนี้
- พยายามแยกส่วนที่เป็นการแสดงผลออกจาก business logic จะได้มากได้น้อยต้องค่อยๆทำไป ยอมรับความจริงว่าต้องเสียเวลากับมัน ต้องยอมลงแรงทำสิ่งที่จะเป็นรากฐานอันมั่นคงสู่ลูกหลาน (เพื่อนๆคุณเธออะ)
- สร้างชายแดนเกาหลีเหนือและเกาหลีใต้ออกมา (middleware) เพื่อที่ชายแดนนี้จะไปจับโค้ดเน่ากับโค้ดใหม่เข้าด้วยกัน และเมื่อมีเวลาค่อยไปจัดการโค้ดเน่าให้ดีขึ้นดุจโค้ดใหม่ ขอให้หาเวลาไปจัดการ ต้องยอมเจ็บปวดแลกกับอนาคต แต่ถ้าอ้างว่าไม่มีเวลา งานเร่ง หัวหน้าก็ควรตัดสินใจเลิกจ้างสมชายเพื่อที่เขาจะได้ไม่ตายคู่สมปองและพา app บริษัทดิ่งลงเหวไปด้วยกัน (แหม ซีรี่เกาหลี)
- เปิดใจใช้เทคโนโลยีใหม่ที่สามารถจัดการ ทั้งยังอำนวยความสะดวกสบายในการโค้ด โค้ดน้อยลง แลดูเป็นระเบียบ สะอาดสุขภาพจิตแจ่มใส ส่งงานทัน ลูกค้ายิ้มรับของที่สั่งได้ในเร็ววัน (ขายฝัน)
>> วันหนึ่งทีมนี้รับสมทรงเข้ามาช่วยงาน แวบแรกที่สมทรงเห็นสุดยอดสังฆกรรมงานบุญที่สมชายทำไว้กับสมปองจนท้องมีลูกเต็มไปหมด เธอก็อุทานโดยไม่รู้ตัวว่า ต๊าย!นี่มันตัวเงินตัวทอง! สมทรงแก้ไขทันที อย่างน้อยๆเธอก็แกะส่วนที่จัดการขนาดของหน้าจอกับการตัดข้อความแล้วใส่จุดจุดจุดออกมาได้ เธอบอกกับทั้งสองสมว่า ต่อไปอย่าเอาจาวาโค้ดมาคำนวณขนาดอีกนะจ๊ะ สมชายยืนขึ้นแล้วตอบกลับ ครับผมจะแก้ไขมัน (เฮ ปรบมือ)
>> อย่างที่บอกไปว่าเขียนด้วย GWT ก็จะเห็นโค้ดจาวา ในที่นี้เพื่อให้คนที่ไม่รู้ GWT พอจะนำโค้ดและหลักการไปประยุกต์ใช้ จึงขอถอด GWT ออกเป็น HTML, CSS และ Java script ดังนี้ครับ
1) ลบ if else นั่นออกไปแล้วหันไปใช้ div แทน
<div></div>
2) ให้ div ข้างต้นหมายถึงพื้นที่สำหรับวางข้อความลงไป สมมติให้มีความกว้าง 60% ของพื้นที่ทั้งหมด เป็นสีชมพู มีความสูงเท่ากับ 18px เราจึงบรรยายลักษณะที่ว่านี้ด้วย CSS คลาสได้เป็น
.demo-area {
width: 60%;
min-height: 18px;
background-color: pink;
}
3) จับใส่ div จึงเขียนได้ว่า
<div class="demo-area"></div>
4) ใช้หลักการของ relative และ absolute สร้างพื้นที่ที่ใช้บรรจุข้อความไว้ภายใน พร้อมกำหนด CSS คลาสและ id
<div class="demo-area">
<div class="container" id="container">
<div class="text-container text-container-width" id="textContainer">
<div class="text-content" id="textContent">
</div>
</div>
</div>
</div>
ดูง่ายๆว่า demo-area อยู่นอกสุด ถัดมาคือ container ถัดมาคือ text-container ถัดไปอีกคือ text-content ก่อนจะใส่ข้อความตัวอย่างลงไป ดังนี้
<div class="text-content" id="textContent">
Android App (The Android developer's cookbook)
</div>
5) โดยให้คลาส container เป็น relative ที่จะขึ้นอยู่กับขนาดของพื้นที่สีชมพู สีชมพูขยายมันขยายตาม สีชมพูหดมันหดตาม
.container {
position: relative;
}
6) ให้คลาส text-container เป็น absolute ลอยอยู่บน container ณ ตำแหน่ง top และ left เป็น 0 (มุมบนซ้าย) เจ้าตัวนี้จะคอยบอกว่าเมื่อไรที่ข้อความยาวเกินกว่าพื้นที่สีชมพู (คีย์สำคัญ)
.text-container {
position: absolute;
top: 0px;
left: 0px;
}
7) เมื่อไรก็ตามที่ text-container ต้องการแสดง ... (จุดจุดจุด) เมื่อความยาวของข้อความเกินกว่าพื้นที่สีชมพู มันต้องถูกจำกัดขอบเขต โดยการเพิ่มคลาสนี้ลงไปด้วย
.text-container-wrap {
width: 100%;
}
8) ให้คลาส text-content คอยจัดการการแสดงผลของข้อความ ในที่นี้คือแสดงให้หมดภายในบรรทัดเดียว เกินกว่าพื้นที่สีชมพูให้ใส่ ... (จุดจุดจุด) ต่อท้าย
.text-content {
white-space: nowrap;
overflow: hidden;
text-overflow: ellipsis;
}
9) และเมื่อไรก็ตามที่มีจุดจุดจุดเกิดขึ้น นั่นแสดงว่าต้องมีป๊อปอัพดึ๋งดั๋งขึ้นมา (ตรงจุดนี้ไม่สำคัญมากนัก แล้วแต่จะประยุกต์ว่าอยากได้ป๊อปอัพหน้าตาอย่างไร มีอีกหลายชื่อ เช่น text balloon บ้างก็เรียก tool-tip ซึ่งก็จะลอยไปติดเจ้า container
.tooltip {
position: absolute;
top: 20px;
left: 10px;
padding: 5px;
border: 1px solid gray;
border-radius: 8px;
}
10) ที่เหลือก็ java script เพื่อคำนวณความกว้างของพื้นที่สีชมพูเทียบกับความยาวของข้อความ โค้ดทั้งหมดสามารถดาวน์โหลดไปดูได้จากลิงค์นี้ครับ
http://www.mediafire.com/view/a3p5op5davfrtil/absolute_example.html
>> นี่อาจจะไม่ใช่วิธีการแก้ปัญหาที่ดีที่สุด รู้แค่ไหนเราแก้ไขไปเท่านั้น ไม่รู้ก็ต้องศึกษา เมื่อรู้ก็นำมาแก้ไขให้งานของเราดีขึ้น แม้เพียงน้อยนิดหากเทียบกับสิ่งที่ทำอยู่ ก็อย่าได้ลืมว่าเราเป็นผู้สร้างเรารู้ดีที่สุด ถึงเราจะไม่ได้สร้างยังมีใจแก้ไข นี่แหละหัวใจของความรับผิดชอบและคิดถึงส่วนรวมครับ ผมน่ะเชื่ออย่างนี้ คืนนี้สวัสดีครับ
>> เรื่องนี้สมชายต้องจัดเต็ม เลิกลูกทุ่งมุ่งสู่อนาคต part 1
>> ได้ขอความรู้จากพี่ซีเนียร์เกี่ยวกับการแสดง popup และการตัดตัวอักษรเมื่อขนาดของ container ไม่แน่นอนด้วย absolute panel ทำให้หมดปัญหาเรื่องการคำนวณความกว้างของ container นั่นหมายความว่ามันสามารถคำนวณความกว้างด้วยตัวของมันเอง โดยไม่ต้องใช้ java โค้ดที่แสนทะมึน
>> อย่างว่าผมเป็นโปรแกรมเมอร์ที่พัฒนาหน้าบ้านด้วย GWT หากจะสมมติให้เห็นตัวอย่างโดยตัด GWT ออกไปก่อน ก็พอจะจำลองงานที่เขียน GWT นี้ด้วย java script กับ CSS ธรรมดา
>> ทว่าก่อนจะถึงเวลานั้น ผมขออนุญาต (ใครสักคน) แชร์สิ่งที่รับทราบมาแบบไม่ต้องคิดมากดังนี้
- ในยุคไดโนเสาร์นั้น GWT โปรแกรมเมอร์ไม่อยากรู้จัก CSS พวกเขาจะคำนวณขนาดของ widget (คิดเอาประมาณว่า container ต่างๆก็แล้วกัน) ทั้งความกว้างและความสูง ด้วยจาวาโค้ด ยกตัวอย่างโค้ดของนายสมชาย
int containerWidth = 0;
if(getBrowserWidth() > 1280) {
containerWidth = 500;
}
กล่าวได้ว่า ถ้าขนาดของหน้าจอ (getBrowserWidth) มากกว่า 1280 px เมื่อไร เจ้า container หรือ widget ของนายสมชายจะมีขนาด 500 px อ๊ะ ก็นายสมชายไม่รู้นี่ไปว่าเขาได้อย่างไร
- เรื่องเว็บ responsive ลืมไปได้เลย เพราะแม้จะผ่านยุคไดโนเสาร์มาแล้ว นายสมชายก็ยังคงความรู้เท่าเดิม วันหนึ่งหัวหน้าบอกกับเขาว่า นี่สมชาย จอขนาด 22 นิ้ว app ของนายดูไม่ดีเลยนะ ปรับความกว้างหน่อย เอาแล้ว งานเข้า แต่สบาย เพราะสมชายทำแบบนี้
int containerWidth = 0;
if(getBrowserWidth() > 1920) {
containerWidth = 1000; //22 นิ้ว
} else if(getBrowserWidth() > 1280) {
containerWidth = 500; //14 นิ้ว
}
กล่าวได้ว่า ถ้าขนาดจอมากกว่า 22 นิ้ว สมชายกำหนดความกว้างได้แล้ว แก้ปัญหาสำเร็จ อิอิ พาหญิงเที่ยวเพลินจิต
- แล้วก็มาถึงยุคหิน และถึกไถ สมชายยังคงมุ่งมั่น if และ else หน้าจอที่มีขนาดแตกต่างกันต่อไปซึ่งตอนนี้มีถึง 10 ขนาด ไม่พอหัวหน้ายังบอกกับเขาอีกว่า เออน้องสม พวกข้อความที่มันยาวเกินบรรทัดไม่ต้องตัดขึ้นบรรทัดใหม่นะ พี่ว่าเราทำเป็น ... (จุดจุดจุด) แล้วแสดงเป็นป๊อปอัพดึ๋งดั๋งขึ้นมาดีกว่า ตกลงตามนี้ไปทำงานได้ โอ้ยสบาย สมชายบอกหัวหน้ากลับไปว่า ง่ายดั่งปีนต้นงิ้ว ซัดเข้าไปอย่างนี้ (ยกมาแค่บางส่วน)
int containerWidth = 0;
int textSize = 0;
if(getBrowserWidth() > 1920) {
containerWidth = 1000;
textSize = 30;
} else if(getBrowserWidth() > 1280) {
containerWidth = 500;
textSize = 15;
} else if...
กล่าวได้ว่า ถ้าขนาดจอ 22 นิ้ว จะมีความยาวของข้อความเต็มที่ที่ 30 ตัวอักษร ถ้าขนาด 14 นิ้ว ก็จะมีความยาวของข้อความเต็มที่ที่ 15 ตัวอักษร หากเกินก็จะใช้จาวาโค้ดตัดข้อความแล้วใส่ จุดจุดจุด เข้าไป แก้ปัญหาสำเร็จ อิอิ พาหญิงเที่ยวนานา
- มาถึงยุคปัจจุบัน ทีมของสมชายโตขึ้น บริษัทโตขึ้น สมชายก็มีลูกน้องหน้าตาดีชื่อสมปองมาร่วมชะตากรรม พอดีสมปองต้องมาแก้โค้ดของสมชาย วินาทีแรกที่เธอได้เห็นสุดยอดสังฆกรรมงานบุญที่สมชายทำไว้ เธอจึงหลุดอุทานออกมาเบาๆแบบไม่รู้ตัวว่า นี่มันตัวเงินตัวทอง! จากนั้นก็ลงมือเขียน if else เข้าไปอีกห้าชุด
>> เรื่องนี้ยังไม่จบ (มีต่อ part 2) ใช้คำแรงไม่ได้เพราะสมชายกับสมปองจิตใจหวั่นไหว คิดเสียว่าอ่านเอามันส์แถมความรู้ก็แล้วกันนะครับ อยากให้คิดอยู่เสมอว่าไม่มีสิ่งใดเกิดมาแล้วดีไปเสียทุกอย่าง ภาษาโปรแกรมมีวิวัฒนาการ มีศาสตร์มีศิลป์อยู่ในตัว ชีวิตของเราก็ไม่ต่างกัน ยอมรับความผิดพลาดแล้วแก้ไขคือพัฒนาการที่ดีของนักเขียนโปรแกรมที่ยึดอาชีพเขียนโปรแกรมหาเงิน ผมเชื่ออย่างนี้ครับ คืนนี้ฝันดีครับผม
>> ทุนที่ได้มาเมื่อหักค่าห้องสำหรับการสอนจะนำไปบริจาคแก่บ้านเด็กพิการทั้งหมด (ซึ่งจะแจ้งให้ทราบในภายหลังครับ)
>> ขณะนี้ผู้เรียนเต็มแล้ว ทว่าเพื่อนคนไหนต้องการสนับสนุนทุนสู่น้องเพิ่ม ติดต่อผม ณ โพสต์นี้ได้ตลอดเลยนะครับ
>> สอนตั้งแต่พื้นฐานกระทั่งแกะเข้าไปในกระดูกของจาวา Servlet อย่างละเอียดที่สุดโดยพี่ซีเนียร์ (บ. Scan-it) ที่มีประสบการณ์ตรงและทำงานด้านนี้มาอย่างยาวนาน (พี่ Max)
>> เข้มข้นตั้งแต่เวลา 9:00 น. ไปจนถึง 16:00 น. (เพียงหนึ่งวัน) เต็มอิ่มกับเนื้อหา Servlet ร้อนๆที่จัดมาเสิร์ฟอย่างไม่ขาดห้วง เคยอ่าน JSP ใช่ไหม รู้ JSF ใช่ไหม พอเขียนจาวา Hello World ได้ใช่ไหม ผมชวนให้มาลงรากกับ Servlet หลังบ้านซึ่งเป็นยอดต่อที่จะทำให้มองเห็นภาพโปรเจ็กต์ในฝันของเราง่ายขึ้น
>> มากด้วยผู้มีประสบการณ์จาวา และทำงานด้านจาวาอีกหลายท่านที่ขนกันมาจากบริษัท ร่วมด้วยช่วยกันปันน้ำใจสู่น้องในวันเสาร์ที่ 16 พฤษภาคมนี้ (2558) ด้วยการมานั่งเรียนจาวา Servlet กันเถอะครับ (ผมก็ไปเรียนด้วย)
>> โครงการดังกล่าวนี้จบไปแล้ว ดังนั้นผมจึงมีความตั้งใจจะถ่ายทอดสิ่งที่เรียนรู้มาสู่เพื่อนๆครับ อ่าน part แรกกันเลย
เรียนรู้ EJB part 2
Message-Driven Beans (MDBs) ขั้นพื้นฐาน
>> เพราะยังคงเวียนวนอยู่กับเรื่อง Message-Driven Beans หรือก็คือ bean ชนิดหนึ่งของ EJB ผมจึงพยายามหาตัวอย่างที่ง่ายที่สุดและพื้นฐานที่สุดเพื่อทำความเข้าใจเรื่องนี้ครับ
>> เท่าที่ทราบ EJB มีสามชนิด ได้แก่
- Session beans
- Message-driven beans
- และ Entity beans (บางองค์ความรู้ไม่กล่าวถึง ทำไมนะ?)
>> bean แต่ละชนิดมีหน้าที่และความเฉพาะเป็นของตัวเองครับ อย่าง Message-Driven Beans ที่ผมกำลังสนใจอยู่นี้ คุณ http://docs.oracle.com/ บอกว่ามันคือ enterprise bean (bean ในเรื่องนี้เป็น enterprise หมดไม่ใช่เหรอจ๊ะ?) ที่สามารถทำงานแบบ asynchronously ห๊ะ?
>> MDBs ที่ว่าดียังไง? ดีตรงที่มันสามารถทำงานกับระบบ message ของ JMS (ณ part1) ได้โดยการรับฟังและรับเอา message ที่มันต้องการไปประมวลผล นอกจากนี้ยังทำงานกับระบบ message ที่มาจาก application client หรือ enterprise bean ต่างๆหรือ web component เป็นต้น
>> asynchronously ล่ะคืออะไร? ในทาง HTML คือการประมวลผลสคริปต์ที่ไม่เป็นลำดับครับ คือสคริปต์ไหนถูกโหลดมาพร้อมแล้วก็เริ่มทำงานได้ อันไหนยังก็โหลดต่อไป ในทาง AJAX คือการไม่ระบุเวลาที่แน่นอนว่าข้อมูลจะถูกส่งกลับมาเมื่อไร เช่นกันสำหรับ MDBs มันจะคอยรับ message ที่มันต้องการ ตราบใดที่มีมันก็รับมา ไม่มีมันก็คอยต่อไป ระหว่างประมวลผลแต่ละ message อยู่นั้นก็ไม่อาจบอกได้ว่าจะเสร็จเมื่อไร เมื่อเสร็จแล้วอาจได้ผลลัพธ์อย่างหนึ่งอย่างใดออกมา อาจมีการแจ้งกลับไปว่าเสร็จแล้วนะ หรืออาจส่งผลลัพธ์ที่ว่าไปทำอย่างอื่นในขั้นตอนต่อไปก็เป็นได้
>> ดังนั้นเมื่อต้องการตัวอย่างของ MDBs สำหรับโปรเจ็กค์ใน NetBeans ก็จะเห็นเป็นรูปเมล็ดถั่วหรือ bean ทำไมล่ะ? ก็เพราะ MDBs คือ bean ชนิดหนึ่งของ EJB (EJB project) นั่นเองครับ
>> ซึ่งก็ได้นำเสนอไปแล้วโดยไม่รู้ตัว ง่า~ มันก็คือตัวที่ implement เจ้า interface ที่ชื่อว่า MessageListener และ override method ที่ชื่อ onMessage ครับ งานของมันในขณะนั้นคือ อ่าน message ออกมาแสดงที่ console ฝั่ง server ไงล่ะ
>> อ่านเพิ่มเติม
- http://docs.oracle.com/javaee/6/tutorial/doc/bnbpk.html
>> คืนนี้กลับมาดึก (ช่วยงานน้องๆ ~ แหม ดูดี) ตัวอย่างไว้โอกาสหน้านะครับ ฝันดีๆ
เรียนรู้ EJB part 1
Working with JMS to send and receive messages example
>> พักนี้ศึกษา EJB กับพี่นรินทรครับ ด้วยความเป็นมือใหม่เมื่อได้มาจับเรื่องนี้ขอยอมรับตรงนี้เลยว่า โอโห! นี่มันงานช้างชัดๆ ทำไม concept มันเยอะอย่างนี้ แต่ก็สนุก เพราะว่าคนสอนเขาเข้าใจคนเรียน น่ารักที่สุด
>> เราเริ่มต้นที่เรื่อง Session Bean ตามด้วยเรื่อง Message-Driven Bean ระหว่างนี้ผมจึงหาตัวอย่างที่เป็น source code เพื่อฝึกทำประกอบ concept ที่ได้เรียนรู้มาครับ
>> อย่างเคย รู้อะไรมาจะผิดหรือถูก ผมจะเอามาแชร์กันก่อน งานในภายหน้าผมเองก็ไม่รู้ว่าจะได้เขียน Java EE ตามความตั้งใจนี้หรือไม่ ในเมื่ออนาคตไม่แน่นอนการมีสิ่งนี้บันทึกไว้จึงเป็นเรื่องดีกว่าไม่มีอะไรเกิดขึ้นเลย หรือปล่อยผ่านให้ลืมเลือนอย่างน่าเสียดาย
>> ตามรูป จะมีเครื่องเซิร์ฟเวอร์อยู่สองเครื่อง เครื่องซ้ายสุดชื่อ server1 และเครื่องขวาสุดชื่อ server2 ตามลำดับ
1. ไคลเอนต์หรือก็คือโปรแกรมเล่นเว็บของเราสมมติมีความต้องการเรียกหน้าเว็บเพจชื่อ index.jsp มาแสดง หน้าดังกล่าวนี้ซึ่งบรรจุอยู่ใน server1 ก็จะถูกนำมาแสดงครับ (ฝั่งนี้ใช้ jsp กับ servlet)
2. เราจึงป้อนข้อความทดสอบลงไปสองข้อความ (มากกว่านี้ก็ได้) ได้แก่ msg1 และ msg2 ข้อความทั้งหมดนี้จะถูกนำไปเก็บไว้ในคิวของ JMS ซึ่งถูก config ไว้ที่ server1 นั่นเอง
3. server2 จะทำหน้าที่อ่านข้อความ (หรืออื่นใด เช่น ออบเจ็กต์) มาจากคิวของ JMS ที่อยู่ ณ server1 แล้วประมวลผล (ฝั่งนี้ใช้ EJB)
4. แสดงผลลัพธ์จากการประมวลผล ในที่นี้คืออ่านข้อความเพื่อเขียนใน console ของ server2 ครับ
>> ตอนนี้ทราบเพียงว่ามันเป็นพื้นฐานของเรื่อง Message-Driven Bean โอกาสต่อไปก็จะนำมาแชร์อีก ผิดถูกอย่างไรผู้รู้แก้ไขให้ผมด้วยนะ ขอบคุณมากครับ
>> แหล่งข้อมูล (ค้นเยอะมาก แต่นี่คือหลักๆ)
- http://www.oracle.com/webfolder/technetwork/tutorials/obe/java/JMSProducer/JMSProducer.html
- http://www.narisa.com/forums/index.php?showtopic=13005
- https://sites.google.com/site/khaekkhab/announcements/javamessageservicejms
หัวหน้าว่าอยากได้ blank chart ถ้าเกิดว่า data มันไม่มี?
>> เวลาวาด chart หรือกราฟ ด้วย Google API เราสามารถเห็น blank chart ได้ถ้าเกิดว่า data มันกลายเป็น ศูนย์ ทุกคอลัมน์ครับ
>> ก็เลยต้องมาเตรียมตัวอย่างทดสอบกันก่อน (test) ให้มีตัวกรองด้วยก็ดี ต้องแบบนี้หรือเปล่า เขียนๆๆ หรือแบบนี้ เขียนๆๆ เอาล่ะไม่มี error ล่ะน่าจะพอโชว์ได้
>> งานชิ้นนี้ลอกตัวอย่างโค้ดจาก
- https://developers.google.com/chart/interactive/docs/animation
>> เป็นกราฟเกี่ยวกับปริมาณงานเขียนนิยายประเภทต่างๆ ในปี 2010, 2020 และ 2030 เทียบกันซึ่งวางในแกน X โดยผลรวมสามารถอ่านค่าได้จากแกน Y
>> ให้ check box เป็นตัวกรอง สามารถเลือกได้ว่าอยากจะตัดนิยายประเภทไหนออกจากกราฟหรือเพิ่มเข้าไปอีกครั้ง (ด้วยค่าเดิม)
>> ดาวน์โหลด .html นี้ได้ที่
- http://www.mediafire.com/view/nmfks1ddfyjq219/animation_chart_example.html
>> หรือเพื่อนๆต้องการรันดูตัวอย่าง โดยไม่ต้องโหลด ได้ที่
- http://goo.gl/CQbLDr
>> สนใจเขียนบ้าง อ่านเพิ่มเติมเกี่ยวกับคำสั่ง DataTable Class
- https://developers.google.com/chart/interactive/docs/reference#DataTable_getValue
>> นั่งทำตั้งแต่สี่ทุ่ม จนบัดนี้ตีสอง เริ่มเงิบแล้ว เอาเป็นว่าฝันดีจ้า zZ
