แหล่งที่มาของบทความ: ฟอรัมฐานข้อมูล ผู้แต่ง: jackma
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(เท็จ);
เป็นที่น่าสังเกตว่าเมื่อปิดฟังก์ชั่น auto-commit แล้ว เราจำเป็นต้องจัดการธุรกรรมด้วยตนเองโดยการเรียกเมธอด commit() และ rollback() ของคลาส Connection
3. ใช้วัตถุคำสั่งใน SQL แบบไดนามิกหรือคำสั่งแบบจำกัดเวลา
เมื่อดำเนินการคำสั่ง SQL เรามีสองตัวเลือก: คุณสามารถใช้วัตถุ ReadyStatement หรือวัตถุ Statement ไม่ว่าคุณจะใช้คำสั่ง 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 คำสั่งจะถูกแยกวิเคราะห์และคอมไพล์โดยฐานข้อมูล จากนั้นนำไปไว้ในบัฟเฟอร์คำสั่ง เมื่อใดก็ตามที่วัตถุ PreparedStatement เดียวกันถูกดำเนินการ มันจะถูกแยกวิเคราะห์อีกครั้ง แต่จะไม่คอมไพล์อีกครั้ง คำสั่งที่คอมไพล์แล้วมีอยู่ในบัฟเฟอร์และสามารถนำมาใช้ซ้ำได้ ในแอปพลิเคชันระดับองค์กรที่มีผู้ใช้จำนวนมาก คำสั่ง SQL เดียวกันมักจะถูกดำเนินการซ้ำๆ กัน การลดจำนวนการคอมไพล์ที่เกิดขึ้นโดยใช้ออบเจ็กต์ ReadyStatement สามารถปรับปรุงประสิทธิภาพโดยรวมของฐานข้อมูลได้ เว้นแต่การสร้าง การจัดเตรียม และการดำเนินการงาน ReadyedStatement บนฝั่งไคลเอ็นต์จะใช้เวลานานกว่างาน Statement ฉันขอแนะนำให้ใช้อ็อบเจ็กต์ PreparedStatement ในทุกกรณี ยกเว้นคำสั่ง SQL แบบไดนามิก
6. ใช้วัตถุ PreparedStatement ในการประมวลผลเป็นชุดของการดำเนินการแทรกหรืออัปเดตซ้ำ <br /> <br /> หากการดำเนินการแทรกและอัปเดตได้รับการประมวลผลเป็นชุด เวลาที่ใช้สำหรับการดำเนินการดังกล่าวจะลดลงอย่างมาก Statement และ CallableStatement ที่จัดทำโดย Oracle ไม่รองรับการประมวลผลแบบแบตช์จริงๆ เท่านั้น เฉพาะอ็อบเจ็กต์ PreparationStatement เท่านั้นที่รองรับการประมวลผลแบบแบตช์ เราสามารถเลือกการประมวลผลแบตช์ JDBC มาตรฐานโดยใช้เมธอด addBatch() และExecuteBatch() หรือเลือกวิธีที่เป็นกรรมสิทธิ์ของ Oracle ที่เร็วกว่าโดยใช้เมธอด หากต้องการใช้กลไกการแบทช์ที่เป็นกรรมสิทธิ์ของ Oracle คุณสามารถเรียก setExecuteBatch() ดังที่แสดงด้านล่าง:
คำสั่งที่เตรียมไว้ pstmt3D เป็นโมฆะ;
พยายาม {
((คำสั่ง OraclePrepared)
pstmt).setExecuteBatch(30);
-
pstmt.executeUpdate();
-