Java Database Connectivity (JDBC) API เป็นชุดอินเทอร์เฟซที่อนุญาตให้โปรแกรมเมอร์ Java เข้าถึงฐานข้อมูล อินเทอร์เฟซของนักพัฒนาต่างๆ ไม่เหมือนกันทุกประการ หลังจากใช้ JDBC ของ Oracle มาหลายปี ฉันได้สั่งสมทักษะมากมายที่ช่วยให้เราใช้ประโยชน์จากประสิทธิภาพของระบบได้ดีขึ้นและบรรลุฟังก์ชันต่างๆ มากขึ้น
1. ใช้ไดรเวอร์ Thin ในการพัฒนาซอฟต์แวร์ไคลเอ็นต์
ในแง่ของการพัฒนาซอฟต์แวร์ Java ฐานข้อมูลของ Oracle มีไดรเวอร์สี่ประเภท โดยสองประเภทใช้สำหรับซอฟต์แวร์ไคลเอ็นต์ เช่น แอปพลิเคชันซอฟต์แวร์ แอปเพล็ต และเซิร์ฟเล็ต และอีกสองประเภทใช้สำหรับ ซอฟต์แวร์ไคลเอ็นต์ เช่น ซอฟต์แวร์แอปพลิเคชัน แอปเพล็ต และซอฟต์แวร์ฝั่งเซิร์ฟเวอร์ เช่น Java ที่จัดเก็บไว้ในฐานข้อมูล ในการพัฒนาซอฟต์แวร์ฝั่งไคลเอ็นต์ เราสามารถเลือกไดรเวอร์ OCI หรือไดรเวอร์ Thin ได้ ไดรเวอร์ OCI ใช้ Java Localization Interface (JNI) เพื่อสื่อสารกับฐานข้อมูลผ่านซอฟต์แวร์ไคลเอนต์ Oracle ไดรเวอร์ Thin เป็นไดรเวอร์ Java แท้ที่สื่อสารโดยตรงกับฐานข้อมูล เพื่อประสิทธิภาพสูงสุด Oracle ขอแนะนำให้ใช้ไดรเวอร์ OCI ในการพัฒนาซอฟต์แวร์ไคลเอ็นต์ และดูเหมือนว่าจะถูกต้อง แต่ฉันแนะนำให้ใช้ไดรเวอร์ Thin เนื่องจากผ่านการทดสอบหลายครั้งพบว่าประสิทธิภาพของไดรเวอร์ Thin นั้นเหนือกว่าไดรเวอร์ OCI ในสถานการณ์ปกติ
2. ปิดฟังก์ชันการส่งอัตโนมัติเพื่อปรับปรุงประสิทธิภาพของระบบ
เมื่อสร้างการเชื่อมต่อกับฐานข้อมูลเป็นครั้งแรก ตามค่าเริ่มต้น การเชื่อมต่อจะอยู่ในโหมดการส่งอัตโนมัติ เพื่อประสิทธิภาพที่ดีขึ้น คุณสามารถปิดฟังก์ชันการส่งอัตโนมัติได้โดยการเรียกเมธอด setAutoCommit() ของคลาส Connection ด้วยพารามิเตอร์ Boolean false ดังต่อไปนี้:
conn.setAutoCommit(false);
เป็นที่น่าสังเกตว่าเมื่อฟังก์ชัน autocommit ถูกปิด เราจำเป็นต้องจัดการธุรกรรมด้วยตนเองโดยการเรียกเมธอด commit() และ rollback() ของคลาส Connection
3. ใช้วัตถุคำสั่งใน SQL แบบไดนามิกหรือคำสั่งแบบจำกัดเวลา
เมื่อดำเนินการคำสั่ง SQL เรามีสองตัวเลือก: คุณสามารถใช้วัตถุที่เตรียมไว้หรือวัตถุคำสั่ง ไม่ว่าคุณจะใช้คำสั่ง SQL เดียวกันกี่ครั้ง ReadyStatement จะวิเคราะห์และคอมไพล์เพียงครั้งเดียวเท่านั้น เมื่อใช้อ็อบเจ็กต์ Statement แต่ละครั้งที่คำสั่ง SQL ถูกดำเนินการ คำสั่งดังกล่าวจะถูกแยกวิเคราะห์และคอมไพล์ นี่อาจทำให้คุณคิดว่าการใช้ออบเจ็กต์ ReadyStatement นั้นเร็วกว่าการใช้ออบเจ็กต์ Statement อย่างไรก็ตาม การทดสอบที่ฉันได้ทำไปแล้วแสดงให้เห็นว่าในซอฟต์แวร์ไคลเอนต์ไม่เป็นเช่นนั้น ดังนั้น ในการดำเนินการ SQL แบบจำกัดเวลา เว้นแต่ว่าคำสั่ง SQL จะถูกประมวลผลเป็นชุด เราควรพิจารณาใช้อ็อบเจ็กต์คำสั่ง
นอกจากนี้ การใช้อ็อบเจ็กต์ Statement ยังทำให้การเขียนคำสั่ง SQL แบบไดนามิกง่ายขึ้น เนื่องจากเราสามารถเชื่อมสตริงเข้าด้วยกันเพื่อสร้างคำสั่ง SQL ที่ถูกต้องได้ ดังนั้น ฉันเชื่อว่าออบเจ็กต์ Statement สามารถทำให้การสร้างและการดำเนินการคำสั่ง SQL แบบไดนามิกง่ายขึ้น
4. ใช้ฟังก์ชันตัวช่วยเพื่อจัดรูปแบบคำสั่ง SQL แบบไดนามิก
เมื่อสร้างคำสั่ง SQL แบบไดนามิกที่ดำเนินการโดยใช้วัตถุคำสั่ง เราจำเป็นต้องจัดการกับปัญหาการจัดรูปแบบบางอย่าง ตัวอย่างเช่น หากเราต้องการสร้างคำสั่ง SQL ที่แทรกชื่อ O'Reilly ลงในตาราง เราจะต้องแทนที่เครื่องหมาย "'" ใน O'Reilly ด้วยเครื่องหมาย "''" สองอันติดต่อกัน วิธีที่ดีที่สุดในการทำงานเหล่านี้ให้สำเร็จคือการสร้างวิธีการช่วยเหลือที่ดำเนินการแทนที่ จากนั้นใช้วิธีการช่วยเหลือที่สร้างขึ้นเมื่อสตริงการเชื่อมต่อแสดงเป็นคำสั่ง SQL โดยใช้สูตร ในทำนองเดียวกัน เราสามารถให้เมธอดตัวช่วยยอมรับค่า Date จากนั้นให้ส่งออกนิพจน์สตริงตามฟังก์ชัน to_date() ของ Oracle
5. ใช้วัตถุ ReadyStatement เพื่อปรับปรุงประสิทธิภาพโดยรวมของฐานข้อมูล
เมื่อใช้วัตถุ ReadyStatement เพื่อรันคำสั่ง SQL คำสั่งจะถูกแยกวิเคราะห์และคอมไพล์โดยฐานข้อมูล จากนั้นวางลงในบัฟเฟอร์คำสั่ง PreparationStatement เดียวกันนั้นจะถูกแยกวิเคราะห์อีกครั้ง แต่จะไม่คอมไพล์อีกครั้ง คำสั่งที่คอมไพล์แล้วมีอยู่ในบัฟเฟอร์และสามารถนำมาใช้ซ้ำได้ ในแอปพลิเคชันระดับองค์กรที่มีผู้ใช้จำนวนมาก คำสั่ง SQL เดียวกันมักจะถูกดำเนินการซ้ำๆ กัน การลดจำนวนการคอมไพล์ที่เกิดขึ้นโดยใช้ออบเจ็กต์ ReadyStatement สามารถปรับปรุงประสิทธิภาพโดยรวมของฐานข้อมูลได้ เว้นแต่การสร้าง การจัดเตรียม และการดำเนินการงาน ReadyedStatement บนฝั่งไคลเอ็นต์จะใช้เวลานานกว่างาน Statement ฉันขอแนะนำให้ใช้อ็อบเจ็กต์ PreparedStatement ในทุกกรณี ยกเว้นคำสั่ง SQL แบบไดนามิก
6. ใช้วัตถุ PreparedStatement เพื่อประมวลผลการแทรกซ้ำหรืออัปเดตการดำเนินการเป็นชุด
หากคุณดำเนินการแทรกและอัปเดตการดำเนินการเป็นชุด คุณสามารถลดเวลาที่ต้องใช้ได้อย่างมาก Statement และ CallableStatement ที่จัดทำโดย Oracle ไม่รองรับการประมวลผลแบบแบตช์จริงๆ เท่านั้น เฉพาะอ็อบเจ็กต์ PreparationStatement เท่านั้นที่รองรับการประมวลผลแบบแบตช์ เราสามารถเลือกการประมวลผลแบตช์ JDBC มาตรฐานโดยใช้เมธอด addBatch() และExecuteBatch() หรือเลือกวิธีที่เป็นกรรมสิทธิ์ของ Oracle ที่เร็วกว่าโดยใช้เมธอด หากต้องการใช้กลไกการแบทช์ที่เป็นกรรมสิทธิ์ของ Oracle คุณสามารถเรียก setExecuteBatch() ได้ดังนี้:
PreparationStatement pstmt3D null;
ลอง {
((OraclePreparedStatement)
pstmt).setExecuteBatch(30);
...
pstmt.executeUpdate()
}
ค่าที่ระบุเมื่อเรียก setExecuteBatch () คือขีดจำกัดสูงสุด เมื่อถึงค่านี้ การดำเนินการคำสั่ง SQL จะถูกทริกเกอร์โดยอัตโนมัติ และวิธีการดำเนินการอัปเดต() มาตรฐานจะถูกส่งไปยังฐานข้อมูลเป็นกระบวนการแบบแบตช์ เราสามารถถ่ายโอนงานแบตช์ได้ตลอดเวลาโดยการเรียกเมธอด sendBatch() ของคลาส ReadyStatement
7. ใช้วิธีระบุตำแหน่ง Oracle เพื่อแทรกและอัปเดตวัตถุขนาดใหญ่ (LOB)
คลาส ReadyStatement ของ Oracle ไม่รองรับการประมวลผลวัตถุขนาดใหญ่เช่น BLOB และ CLOB โดยเฉพาะอย่างยิ่งไดรเวอร์ Thin ไม่รองรับการตั้งค่าโดยใช้ setObject() และเมธอด setBinaryStream() ของอ็อบเจ็กต์ PreparationStatement ค่าของ BLOB ไม่รองรับการตั้งค่าของ CLOB โดยใช้เมธอด setCharacterStream() เฉพาะวิธีการในตัวระบุตำแหน่งเท่านั้นที่สามารถรับค่าประเภท LOB จากฐานข้อมูลได้ คุณสามารถใช้ออบเจ็กต์ ReadyStatement เพื่อแทรกหรืออัปเดต LOB ได้ แต่คุณจำเป็นต้องใช้ตัวระบุตำแหน่งเพื่อรับค่าของ LOB เนื่องจากปัญหาทั้งสองนี้ ฉันขอแนะนำให้ใช้วิธีระบุตำแหน่งเพื่อแทรก อัปเดต หรือรับค่า LOB
8. ใช้ไวยากรณ์ SQL92 เพื่อเรียก Stored Procedures
เมื่อเรียก Stored Procedure เราสามารถใช้ SQL92 หรือ Oracle PL/SQL ได้ ไม่มีประโยชน์ในทางปฏิบัติในการใช้ Oracle PL/SQL และจะสร้างปัญหาให้กับ Developer ที่จะดูแล Application ของคุณ อนาคตเกิดปัญหา ดังนั้นฉันขอแนะนำให้ใช้ SQL92 เมื่อเรียกกระบวนงานที่เก็บไว้
9. ใช้ Object SQL เพื่อถ่ายโอนสคีมาออบเจ็กต์ไปยังฐานข้อมูล
เนื่องจากฐานข้อมูลของ Oracle สามารถใช้เป็นฐานข้อมูลเชิงวัตถุได้ คุณจึงสามารถพิจารณาถ่ายโอนสคีมาเชิงวัตถุในแอปพลิเคชันไปยังฐานข้อมูลได้ วิธีการปัจจุบันคือการสร้าง Java bean ให้เป็นอ็อบเจ็กต์ฐานข้อมูลปลอม แมปคุณสมบัติลงในตารางเชิงสัมพันธ์ แล้วเพิ่มเมธอดให้กับ bean เหล่านี้ แม้ว่าจะไม่มีปัญหาในการดำเนินการนี้ใน Java เนื่องจากการดำเนินการดำเนินการนอกฐานข้อมูล แอปพลิเคชันซอฟต์แวร์อื่นๆ ที่เข้าถึงฐานข้อมูลจึงไม่สามารถใช้ประโยชน์จากโมเดลออบเจ็กต์ได้ หากคุณใช้ประโยชน์จากเทคโนโลยีเชิงวัตถุของ Oracle คุณสามารถจำลองข้อมูลและการดำเนินงานในฐานข้อมูลได้โดยการสร้างประเภทวัตถุฐานข้อมูลใหม่ จากนั้นใช้เครื่องมือ เช่น JPublisher เพื่อสร้างคลาส Java bean ของคุณเอง หากคุณใช้วิธีนี้ ไม่เพียงแต่แอปพลิเคชัน Java เท่านั้นที่สามารถใช้โมเดลออบเจ็กต์ของแอพพลิเคชั่นซอฟต์แวร์ได้ แต่แอพพลิเคชั่นซอฟต์แวร์อื่น ๆ ที่ต้องการแบ่งปันข้อมูลและการดำเนินการในแอพพลิเคชั่นของคุณยังสามารถใช้โมเดลออบเจ็กต์ของแอพพลิเคชั่นซอฟต์แวร์ได้อีกด้วย
10. ใช้ SQL เพื่อดำเนินการในฐานข้อมูลให้เสร็จสมบูรณ์
ประสบการณ์ที่สำคัญที่สุดที่ฉันอยากแนะนำให้คุณรู้จักคือการใช้ประโยชน์จากแนวทางการตั้งค่าของ SQL อย่างเต็มรูปแบบเพื่อแก้ไขความต้องการในการประมวลผลฐานข้อมูล แทนที่จะใช้ภาษาโปรแกรมขั้นตอนเช่น Java
หากโปรแกรมเมอร์ต้องค้นหาหลายแถวในตารางเดียว แต่ละแถวในผลลัพธ์จะค้นหาข้อมูลในตารางอื่น ในที่สุด โปรแกรมเมอร์ได้สร้างคำสั่ง UPDATE แยกต่างหากเพื่ออัปเดตข้อมูลในตารางแรกเป็นชุด งานที่คล้ายคลึงกันนี้สามารถทำได้สำเร็จในคำสั่ง UPDATE โดยใช้แบบสอบถามย่อยแบบหลายคอลัมน์ใน set clause เหตุใดจึงต้องปล่อยให้ข้อมูลไหลผ่านอินเทอร์เน็ต ในเมื่อคุณสามารถทำงานให้สำเร็จได้ด้วยคำสั่ง SQL คำสั่งเดียว ฉันแนะนำให้ผู้ใช้เรียนรู้วิธีเพิ่มพลังของ SQL อย่างละเอียดถี่ถ้วน
ผู้แต่ง: picva ที่มา: ชุมชนเทคโนโลยี CCID