อย่างที่เราทราบกันว่า Java Database Connectivity (JDBC) เป็นหนึ่งในกลวิธีของจาวา API ที่สร้างขึ้นมาเพื่อติดต่อหรือเข้าถึงเพื่อใช้งานฐานข้อมูลเชิงสัมพันธ์ (relational databases) ด้วยภาษาจาวา
>> และวิธีการใช้ JDBC ติดต่อไปยังฐานข้อมูลโดยหลักการ Object-Relational Mappin (ORM) ก็คือการเขียนจาวาคลาสธรรมดาที่เรียกว่า model ให้สามารถพูดคุยหรือสื่อสารไปยังฐานข้อมูลเชิงสัมพันธ์ได้
ได้อย่างไร?
ได้โดยคนกลางที่ implement หลักการ ORM นี้ไงล่ะ ย่อมเป็นใครก็ได้ ทว่าขณะนี้เราสนใจเพียงเขาคนเดียว เขาก็คือ Hibernate framework
>> Hibernate จะทำหน้าที่แปลง (convert) ข้อมูลที่ถูกส่งระหว่างฐานข้อมูลเชิงสัมพันธ์กับภาษาโปรแกรมที่ใช้หลักการ OOP ซึ่งในที่นี้ก็คือภาษาจาวานั่นเอง
>> แต่ก่อนที่การแปลงนี้จะเกิดขึ้น เราผู้เป็นนักพัฒนาจะต้องจับคู่จาวาคลาสธรรมดาเข้ากับตารางในฐานข้อมูลเสียก่อน ระบุชนิดข้อมูลทางฝั่งจาวาเข้ากับชนิดข้อมูลของฟิลด์ทางฝั่งตารางในฐานข้อมูล
>> เหล่าออบเจ็กต์ที่ Hibernate จะทำงานด้วยเรียกว่า persistent object ซึ่งจะถูกทำให้เกิดขึ้นโดย Hibernate อ่านค่า configuration ที่นักพัฒนาได้กำหนดเอาไว้ผ่านบริการที่เรียกว่า persistence services จากคอร์คลาสจำนวนหนึ่งที่ Hibernate จัดเตรียมไว้ให้ครับ
>> คอร์คลาส (core classes) ที่สำคัญได้แก่
- Configuration
- Session Factory
- Session
- Transaction
- Query
- Criteria
>> แต่มันยังไม่พอ... อะไรนะ? Hibernate ยังต้องพึ่งพา Java API ที่สำคัญยิ่งอีกสามกลุ่ม (ขอยืมแขนขาหน่อยเธอ) ได้แก่
- JDBC
- Java Naming and Directory Interface (JNDI)
- Java Transaction API (JTA)
>> JDBC ก็ใช้ติดต่อไปยังฐานข้อมูล, JNDI กับ JTA จะทำให้ Hibernate ทำงานร่วมกับ J2EE application servers ได้ (เช่น จาวาเว็บที่เขียนด้วย JSP & Servlet ไง เชื่อว่าเพื่อนๆน่าจะรู้จักกันอยู่)
>> Hibernate เป็นคนกลางที่ทำหน้าที่สร้าง persistent object ระหว่างฝั่งโปรแกรมจาวากับฐานข้อมูลได้อย่างไรนะ?
อ้อ ได้อย่างนี้จ๊ะ Hibernate ต้องการเส้นทางและระยะเวลาการคุยกันระหว่างโปรแกรมจาวากับฐานข้อมูล พูดในทางจาวาเว็บก็คือเส้นทางและระยะเวลาการคุยกันระหว่าง client กับ server สิ่งนี้เรียกว่า session
session จะมีอยู่ตลอดไประหว่างการสื่อสารดังกล่าว การให้ความสำคัญกับสถานะของข้อมูลหรือก็คือข่าวสารที่คุยกัน หรือพูดได้ว่าเกิดการติดตาม state ของข้อมูลเรียกว่า stateful คืออยู่ในหน่วยความจำเสมอ
ทว่าตรงข้าม การไม่ใช้หน่วยความจำเพื่อจดจำ state ของข้อมูล นี่จะเรียกว่า stateless ตัวอย่าง
A: สวัสดี B ฉันชื่อ A นะ
B: สวัสดี A ฉันชื่อ B จ๊ะ
A: มีเหตุระเบิดเกินขึ้นอีกแล้วเธอรู้ไหม B! (แทนที่ B จะคุยต่อ มันดันถาม...)
B: เธอเป็นใคร
A: สวัสดี B ฉันชื่อ A นะ
B: สวัสดี A ฉันชื่อ B จ๊ะ (แล้วทั้งคู่ก็คุยกันต่อ พักๆก็ลืมกันอีก)
หนึ่งในประโยชน์ของ stateless คือการใช้หน่วยความจำหนุมเวียน เกิดการ reuse บ่อยครั้งไม่เปลืองทรัพยากรเครื่อง server
อธิบายเรื่องนี้เพราะว่า session ที่ Hibernate ต้องการคือ stateful ซึ่งนำมาสู่การใช้ transaction (JTA)
>> ตัวอย่างเช่น ถอนเงินจากธนาคาร 500 บาท ก็จะเกิดการหักบัญชีที่ถูกถอนนั้น 500 บาทจริงไหม (สมมติไม่มีค่าธรรมเนียมนะจ๊ะเธอ) จากนั้นแบ่งเงินที่ได้รับมา 300 บาทฝากใส่บัญชีแฟนเก่า ก็จะเกิดการบวกเพิ่มเงินของบัญชีที่ถูกฝากนั้นจริงไหมหือ (สมมติไม่มีค่าธรรมเนียมนะทูลหัว)
สิ่งที่เกิดขึ้นนี้เรียกว่า atomic transactional ซึ่งมีผลเพียงสองประการ
1) สำเร็จทั้งหมด ถอน 500 และฝาก 300 สำเร็จทั้งคู่
2) ล้มเหลวทั้งหมด ถอน 500 และฝาก 300 ล้มเหลวทั้งคู่
>> เอาล่ะทฤษฎีพอแล้ว part ต่อไปเราจะใช้ Eclipse เขียนโปรแกรมที่ว่านี้กัน เราจะขอออบเจ็กต์ session จากคลาสโรงงานที่ชื่อ SessionFactory มาเพื่อเริ่มทำ transaction หรือก็คือธุรกรรม ครั้นเมื่อกระทำธุรกรรมเสร็จก็จะปิด transaction ดังกล่าวก่อนจะปิด session ในลำดับถัดไป คืนนี้ฝันดี ระวังตัวและดูแลตัวเอง บึ้ม! สวัสดีครับ
***หมายเหตุ รูปภาพทั้งหมดนำมาจาก www.tutorialspoint.com
ไม่มีความคิดเห็น:
แสดงความคิดเห็น