บทความนี้จะอธิบายความรู้และทักษะพื้นฐานของ JDBC พร้อมตัวอย่าง แบ่งปันกับทุกคนสำหรับการอ้างอิงของคุณ การวิเคราะห์เฉพาะมีดังนี้:
1. เจดีบีซี คืออะไร?
ในแง่ของคนทั่วไป เทคโนโลยี JDBC ใช้โปรแกรม Java เพื่อส่งคำสั่ง SQL ไปยังฐานข้อมูล ฐานข้อมูลดำเนินการคำสั่ง SQL หลังจากได้รับคำสั่งเหล่านั้น และส่งกลับผลลัพธ์ไปยังโปรแกรม Java เพื่อการจัดการ
2. เงื่อนไขการใช้ JDBC มีอะไรบ้าง?
A) ที่อยู่ของโฮสต์ฐานข้อมูลเป้าหมาย
B) หมายเลขพอร์ตที่ซอฟต์แวร์ฐานข้อมูลบนโฮสต์ครอบครอง
C) ชื่อผู้ใช้ที่ใช้ในการเข้าสู่ระบบฐานข้อมูล
D) รหัสผ่านสำหรับชื่อผู้ใช้นั้น
E) เชื่อมต่อกับฐานข้อมูล
3.หลักการของเทคโนโลยี JDBC
เรารู้ว่ามีฐานข้อมูลหลายประเภท และมาตรฐานฐานข้อมูลและข้อกำหนดที่ผลิตโดยผู้ผลิตแต่ละรายนั้นแตกต่างกัน ในเวลานี้ หากเราใช้โค้ด JAVA เพื่อส่งคำสั่ง SQL เราจะต้องเขียนชุดต่อชุดตามฐานข้อมูลที่ต่างกัน ชุดรหัสการดำเนินการซึ่งเป็นต้นทุนการพัฒนามหาศาลสำหรับนักพัฒนาโปรแกรม ดังนั้น SU เมื่อบริษัท N พัฒนาเทคโนโลยี JDBC ผู้ผลิตฐานข้อมูลจะต้องจัดเตรียมไดรเวอร์เพื่อใช้ชุดอินเทอร์เฟซนี้ จากนั้น ตราบใดที่นักพัฒนาโปรแกรมใช้ไดรเวอร์ของฐานข้อมูลในระหว่างการพัฒนา พวกเขาจะต้องใช้วิธีการที่สอดคล้องกัน ในการพัฒนาไม่จำเป็นต้องเขียนชุดโค้ดเพื่อปรับให้เข้ากับฐานข้อมูลต่างๆ
4. Core API ใน JDBC
|- ไดรเวอร์: อินเทอร์เฟซที่ใช้งานโดยคลาสไดรเวอร์
|-การเชื่อมต่อการเชื่อมต่อ (URL สตริง ข้อมูลคุณสมบัติ) --ใช้เพื่อเชื่อมต่อกับฐานข้อมูลและรับอ็อบเจ็กต์การเชื่อมต่อ
พารามิเตอร์ที่ต้องตั้งค่าในคุณสมบัติ:
url: สตริง URL ของการเชื่อมต่อฐานข้อมูล โปรโตคอล+ฐานข้อมูล โปรโตคอลย่อย+โฮสต์+พอร์ต+ฐานข้อมูล
ผู้ใช้: ชื่อผู้ใช้ฐานข้อมูล
รหัสผ่าน: รหัสผ่านของผู้ใช้
|-การเชื่อมต่อ: อินเทอร์เฟซสำหรับเชื่อมต่อกับฐานข้อมูล
|- คำสั่ง createStatement() --สร้างวัตถุคำสั่งสำหรับส่งคำสั่ง sql
|- PreparationStatement waitStatement(String sql) - สร้างวัตถุ PreparationStatement สำหรับการส่งคำสั่ง sql ที่คอมไพล์แล้ว
|-CallableStatement waitCall(String sql) --สร้างวัตถุ CallableStatement สำหรับการเรียกกระบวนงานที่เก็บไว้
|-คำสั่ง: ใช้เพื่อรันคำสั่ง sql แบบคงที่
|-int runUpdate(String sql) --ดำเนินการอัพเดต (DDL+DML)
|-ResultSetExecuteQuery(String sql) --ดำเนินการดำเนินการสืบค้น (DQL)
|- ReadyStatement: ใช้เพื่อรันคำสั่ง SQL ที่คอมไพล์แล้ว
|- int runUpdate() -- ดำเนินการอัพเดต
|- ResultSetExecuteQuery() -- ดำเนินการดำเนินการสืบค้น
|- CallableStatement: sql ใช้เพื่อดำเนินการขั้นตอนที่เก็บไว้
|- ResultSetExecuteQuery() --เรียกโพรซีเดอร์ที่เก็บไว้
|- ResultSet: ชุดผลลัพธ์ ใช้เพื่อห่อหุ้มข้อมูลแบบสอบถามของฐานข้อมูล
|- boolean next() --เลื่อนเคอร์เซอร์บันทึกไปที่บรรทัดถัดไป
|- Object getObject(int columnIndex) -- รับค่าของฟิลด์
หลังจากทำความเข้าใจว่า API ใดแล้ว มาใช้ JDBC เพื่อส่งคำสั่ง SQL กันดีกว่า~
5. ใช้วัตถุคำสั่งเพื่อดำเนินการฐานข้อมูล
การดำเนินการ DDL และ DML
ขั้นตอนที่ 1
นำเข้าแพ็คเกจ เนื่องจากฉันใช้ฐานข้อมูล MySQL ดังนั้นในการใช้เทคโนโลยี JDBC คุณต้องใช้ไดรเวอร์ฐานข้อมูลที่ผู้ผลิตฐานข้อมูล MySQL ให้มา ดังนั้น ขั้นตอนแรกคือการนำเข้าแพ็คเกจไดรเวอร์ฐานข้อมูลเข้าสู่โปรเจ็กต์
ชื่อแพ็คเกจที่ใช้: mysql-connector-java-5.1.7-bin.jar
ขั้นตอนที่ 2
สร้างคลาสธรรมดา เพิ่มเมธอดลงไป และคัดลอกโค้ดในเมธอดดังนี้: //URL
URL สตริงส่วนตัว = "jdbc:mysql://localhost:3306/vmaxtam";
//ผู้ใช้
ผู้ใช้สตริงส่วนตัว = "root";
//รหัสผ่าน
รหัสผ่านสตริงส่วนตัว = "root";
โมฆะสาธารณะ testDDL () พ่นข้อยกเว้น {
//1.ลงทะเบียนไดรเวอร์
Class.forName("com.mysql.jdbc.Driver");
//2. รับการเชื่อมต่อ
การเชื่อมต่อ conn = DriverManager.getConnection (url, ผู้ใช้, รหัสผ่าน);
//3. สร้างวัตถุคำสั่ง
คำสั่ง stmt = conn.createStatement();
//4. เตรียมคำสั่ง sql
String sql = "สร้างตารางนักเรียน (sid INT คีย์หลัก, ชื่อ VARCHAR (20), อายุ INT)";
//5. ส่งคำสั่ง sql ผ่านวัตถุคำสั่งและส่งคืนผลการดำเนินการ
จำนวน int = stmt.executeUpdate (sql);
//6.พิมพ์ผลการดำเนินการ
System.out.println("บันทึกที่ได้รับผลกระทบ "+นับ+"");
-
//7. ปิดทรัพยากร
ถ้า(คำสั่ง!=null)
-
คำสั่งปิด();
-
ถ้า(conn!=null)
-
conn.ปิด();
-
หากคุณต้องการดำเนินการ DQL และ DDL คุณสามารถเขียนคำสั่ง SQL จากนั้นเรียกใช้เมธอด executlUpdate ของคำสั่งเพื่อดำเนินการคำสั่ง SQL สำหรับฐานข้อมูล เมธอดนี้จะส่งคืนค่าจำนวนเต็มที่ระบุจำนวนแถวในฐานข้อมูลที่ได้รับผลกระทบ
หากเราไม่เปลี่ยนโปรแกรมข้างต้นและต้องการออกคำสั่ง SQL ไปยังฐานข้อมูลอีกครั้งเราก็ต้องเขียนโปรแกรมเพื่อเชื่อมต่ออีกครั้งและหลังจากดำเนินการแล้วเราก็ต้องปิดคำสั่ง object และ object การเชื่อมต่อซึ่งยุ่งยากมาก . ดังนั้นเราจึงแยกกระบวนการเชื่อมต่อและกระบวนการเผยแพร่อ็อบเจ็กต์ออกเป็นคลาสเครื่องมือโดยทั่วไป รหัสในคลาสเครื่องมือมีดังนี้:
คัดลอกรหัสดังต่อไปนี้: คลาสสาธารณะ sqlUtil {
url สตริงคงที่ส่วนตัว = "jdbc:mysql://localhost:3306/vmaxtam";
ผู้ใช้สตริงคงที่ส่วนตัว = "root";
รหัสผ่านสตริงคงที่ส่วนตัว = "root";
// รับการเชื่อมต่อ
การเชื่อมต่อสาธารณะแบบคงที่ getconnection () {
การเชื่อมต่อการเชื่อมต่อ = null;
พยายาม {
// 1. ลงทะเบียนไดรเวอร์
Class.forName("com.mysql.jdbc.Driver");
// 2. รับการเชื่อมต่อ
conn = DriverManager.getConnection (url, ผู้ใช้, รหัสผ่าน);
// 3. รับวัตถุคำสั่ง
คำสั่งงบ = conn.createStatement();
} จับ (ข้อยกเว้นจ) {
// TODO บล็อก catch ที่สร้างขึ้นอัตโนมัติ
e.printStackTrace();
-
กลับคอน;
-
// 7. ปิดทรัพยากร
การปิดโมฆะคงที่สาธารณะ (คำสั่งคำสั่ง, การเชื่อมต่อการเชื่อมต่อ) {
-
พยายาม {
ถ้า (คำสั่ง != null)
คำสั่งปิด();
ถ้า (การเชื่อมต่อ != null) {
การเชื่อมต่อ.ปิด();
-
} จับ (SQLException e) {
// TODO บล็อก catch ที่สร้างขึ้นอัตโนมัติ
e.printStackTrace();
-
-
-
-
สิ่งที่ต้องพิจารณาคือ:
1) ผู้ใช้จำเป็นต้องลงทะเบียนไดรเวอร์เพียงครั้งเดียว ไม่จำเป็นต้องลงทะเบียนไดรเวอร์ทุกครั้งที่เชื่อมต่อกับฐานข้อมูล ดังนั้นเราจึงเขียนขั้นตอนการลงทะเบียนไดรเวอร์ในบล็อกรหัสคงที่
2) URL, ชื่อผู้ใช้, รหัสผ่าน และชื่อคลาสไดรเวอร์เป็นฮาร์ดโค้ดในโปรแกรม เพื่อให้สามารถเปลี่ยนฐานข้อมูลหรือผู้ใช้โดยไม่ต้องเปลี่ยนรหัส เรามักจะเขียนข้อมูลนี้ลงในไฟล์กำหนดค่า
ไฟล์คอนฟิกูเรชันถูกเขียนในไดเร็กทอรี src ของโปรเจ็กต์และมีชื่อว่า db.properties
คัดลอกโค้ดดังนี้: url=jdbc:mysql://localhost:3306/vmaxtam
ผู้ใช้ = รูท
รหัสผ่าน=รูท
driverClass=com.mysql.jdbc.ไดรฟ์
จากนั้นอ่านไฟล์การกำหนดค่าใน sqlUtil และสุดท้ายปรับให้เป็นโค้ดต่อไปนี้: คลาสสาธารณะ sqlUtil {
url สตริงคงที่ส่วนตัว = null;
ผู้ใช้สตริงคงที่ส่วนตัว = null;
รหัสผ่านสตริงคงที่ส่วนตัว = null;
driverClass สตริงคงที่ส่วนตัว = null;
คงที่{
พยายาม {
//1. รับวัตถุ bytecode
Classclazz = sqlUtil.คลาส;
//2. เรียก getResourceAsStream เพื่อรับเส้นทาง
InputStream inputStream = clazz.getResourceAsStream("/db.properties");
Properties pro = คุณสมบัติใหม่ ();
pro.load(อินพุตสตรีม);
//3. อ่านพารามิเตอร์
url=pro.getProperty("url");
รหัสผ่าน=pro.getProperty("รหัสผ่าน");
ผู้ใช้=pro.getProperty("ผู้ใช้");
driverClass=pro.getProperty("ไดร์เวอร์คลาส");
Class.forName(คลาสไดรเวอร์);
} จับ (ข้อยกเว้นจ) {
e.printStackTrace();
System.out.println("การลงทะเบียนล้มเหลว!" + e.getMessage());
โยน RuntimeException ใหม่ (e);
-
-
// รับการเชื่อมต่อ
การเชื่อมต่อสาธารณะแบบคงที่ getconnection () {
การเชื่อมต่อการเชื่อมต่อ = null;
พยายาม {
// รับการเชื่อมต่อ
conn = DriverManager.getConnection (url, ผู้ใช้, รหัสผ่าน);
// รับวัตถุคำสั่ง
คำสั่งงบ = conn.createStatement();
} จับ (ข้อยกเว้นจ) {
e.printStackTrace();
-
กลับคอน;
-
// ปิดทรัพยากร
การปิดโมฆะคงที่สาธารณะ (คำสั่งคำสั่ง, การเชื่อมต่อการเชื่อมต่อ) {
-
พยายาม {
ถ้า (คำสั่ง != null)
คำสั่งปิด();
ถ้า (การเชื่อมต่อ != null) {
การเชื่อมต่อ.ปิด();
-
} จับ (SQLException e) {
// TODO บล็อก catch ที่สร้างขึ้นอัตโนมัติ
e.printStackTrace();
-
-
-
-
การทำงานของดีคิวแอล
แล้วจะใช้ JDBC เพื่อสืบค้นข้อมูลในฐานข้อมูลได้อย่างไร?
คัดลอกโค้ดโค้ดดังนี้: @Test
โมฆะสาธารณะ testdsl () ส่งข้อยกเว้น {
//รับการเชื่อมต่อ
cnn2=sqlUtil.getconnection();
คำสั่งงบ = cnn2.createStatement();
//เตรียมคำสั่ง SQL
String sql = "เลือก * จากหัวเรื่อง";
//เรียกดำเนินการแบบสอบถามเพื่อดำเนินการคำสั่งแบบสอบถาม
ResultSet res = state.executeQuery(sql);
//หลังจากการสืบค้นเสร็จสมบูรณ์ res จะชี้ไปที่ส่วนหัวของตาราง หากคุณต้องการรับข้อมูล คุณต้องชี้ไปที่แถวถัดไปของผลลัพธ์การสืบค้น เมื่อไม่มีข้อมูลแถวถัดไป จะส่งกลับ 0
ในขณะที่(res.next())
-
//รับค่าของฟิลด์ "sjid" ในผลลัพธ์แบบสอบถาม และตรวจสอบให้แน่ใจว่าประเภทนั้นชัดเจน
int id = res.getInt("sjid");
//รับค่าของฟิลด์ "sjname" ในผลลัพธ์แบบสอบถาม และประเภทจะต้องชัดเจน
ชื่อสตริง = res.getString("sjname");
System.out.println("ID:" + id + "NAME:" + ชื่อ);
-
sqlUtil.close (คำสั่ง, cnn2);
-
ข้างต้นคือการใช้วัตถุคำสั่งเพื่อดำเนินการฐานข้อมูล~
6. ใช้ ReadyStatement เพื่อดำเนินการฐานข้อมูล
จริงๆ แล้ววัตถุ PreparedStatement เป็นวัตถุคำสั่งพิเศษที่สามารถคอมไพล์คำสั่ง SQL ล่วงหน้าได้ เมื่อคุณตั้งค่าพารามิเตอร์ คุณสามารถดำเนินการคำสั่ง SQL ได้~
รหัสคัดลอกการดำเนินการ DDL และ DML มีดังนี้ แพคเกจ com.vmaxtam.sqltest;
นำเข้า java.sql.Connection;
นำเข้า java.sql.PreparedStatement;
นำเข้า org.junit.Test;
คลาสสาธารณะ ReadyedStatementTest {
การเชื่อมต่อการเชื่อมต่อ = null;
@ทดสอบ
โมฆะสาธารณะ ddldmlTest () พ่นข้อยกเว้น {
// 1. รับการเชื่อมต่อ
การเชื่อมต่อ = sqlUtil.getconnection();
// 2. เตรียมคำสั่ง SQL, คำสั่งที่คอมไพล์แล้ว และพารามิเตอร์? ตัวยึดตำแหน่งหมายเลข
String sql = "แทรกเข้าไปในค่าของหัวเรื่อง(?,?)";
// 3. รับวัตถุ
PreparationStatement readyStatement = การเชื่อมต่อ.prepareStatement(sql);
-
* 4. ในการตั้งค่าพารามิเตอร์ SQL คุณต้องทราบหมายเลขพารามิเตอร์และทราบประเภทของพารามิเตอร์ ประโยคแรกด้านล่างระบุว่า: พารามิเตอร์แรกของคำสั่ง SQL เป็นประเภท int และค่าพารามิเตอร์ถูกตั้งค่าเป็น 3 และดังนั้น บน.
-
readyStatement.setInt(1, 3);
readyStatement.setString(2, "ภาษาอังกฤษ");
// 5. ส่งต่อไปยังฐานข้อมูลเพื่อรัน SQL
int num = readyStatement.executeUpdate();
System.out.println("มี" + num + "บันทึกที่ได้รับผลกระทบ");
sqlUtil.close(preparedStatement, การเชื่อมต่อ);
-
-
ข้างต้นคือการใช้วัตถุPreparedStatementเพื่อส่งคำสั่งการแทรกในลักษณะเดียวกันสามารถส่งคำสั่ง DDL และ DML ในลักษณะนี้ได้
ประโยชน์ของการคอมไพล์ล่วงหน้าของ ReadyStatement:
การคอมไพล์ล่วงหน้าของ Precompilation ช่วยให้คุณสามารถสืบค้นเป้าหมายที่แตกต่างกันโดยการตั้งค่าพารามิเตอร์ที่แตกต่างกัน ในด้านฐานข้อมูล เฉพาะคำสั่งที่คอมไพล์แล้วเท่านั้นที่จะถูกบันทึก แต่ถ้าคุณใช้ Statement เพื่อส่งคำสั่ง แต่ละครั้งที่ส่งคำสั่ง หนึ่งคำสั่งจะถูกเก็บไว้ใน ฐานข้อมูลซึ่งอาจใช้หน่วยความจำมาก
รหัสคัดลอกการดำเนินการ DQL เป็นดังนี้: @Test
โมฆะสาธารณะ dqlTest() ส่งข้อยกเว้น {
// 1. รับการเชื่อมต่อ
การเชื่อมต่อ = sqlUtil.getconnection();
// 2. เตรียมคำสั่ง SQL, คำสั่งที่คอมไพล์แล้ว และพารามิเตอร์? ตัวยึดตำแหน่งหมายเลข
String sql = "select * จากเรื่องโดยที่ sjid=? หรือ sjname=?";
// 3. รับวัตถุ
PreparationStatement readyStatement = การเชื่อมต่อ.prepareStatement(sql);
-
* 4. ในการตั้งค่าพารามิเตอร์ SQL คุณต้องทราบหมายเลขพารามิเตอร์และทราบประเภทของพารามิเตอร์ ประโยคแรกด้านล่างระบุว่า: พารามิเตอร์แรกของคำสั่ง SQL เป็นประเภท int และค่าพารามิเตอร์ถูกตั้งค่าเป็น 3 และดังนั้น บน.
-
readyStatement.setInt(1, 2);
readyStatement.setString(2, "ภาษาจีน");
// 5. ส่งต่อไปยังฐานข้อมูลเพื่อรัน SQL
ResultSet rst = readyStatement.executeQuery();
//6.ทำซ้ำชุดผลลัพธ์
ในขณะที่(rst.next())
-
int id = rst.getInt("sjid");
ชื่อสตริง = rst.getString("sjname");
System.out.println("ID:" + id + "NAME:" + ชื่อ);
-
//7. ปิดการเชื่อมต่อ
sqlUtil.close(preparedStatement, การเชื่อมต่อ);
-
คุณยังสามารถเรียกใช้เมธอดExecutiveQuery(); และทำซ้ำเอาต์พุตหลังจากได้รับชุดผลลัพธ์~
เนื่องจากคำชี้แจงและคำชี้แจงที่เตรียมไว้มีความคล้ายคลึงกันมาก มาเปรียบเทียบข้อดีและข้อเสียกันดีกว่า~
ความแตกต่างระหว่างคำชี้แจงและคำชี้แจงที่เตรียมไว้:
1. ไวยากรณ์ที่แตกต่างกัน
คำสั่งรองรับเฉพาะการคอมไพล์แบบคงที่ และคำสั่ง SQL เป็นแบบฮาร์ดโค้ด
ReadyStatement รองรับการคอมไพล์ล่วงหน้าใช้ไหม? มานั่งกัน
2. ประสิทธิภาพที่แตกต่าง
คำสั่งจะส่งคำสั่ง SQL ทุกครั้ง ไม่รองรับการแคช และมีประสิทธิภาพในการดำเนินการต่ำ
PreparationStatement รองรับการคอมไพล์ล่วงหน้าและถูกแคชไว้ในฐานข้อมูล เพียงส่งพารามิเตอร์เท่านั้น และประสิทธิภาพการดำเนินการก็รวดเร็ว
3. ความปลอดภัยที่แตกต่างกัน
คำสั่งถูกฉีดอย่างง่ายดาย
การฉีด: องค์ประกอบเจ้าเล่ห์สามารถเขียนคำสั่ง SQL พิเศษเพื่อโจมตีฐานข้อมูลได้
ตัวอย่างเช่น: เพื่อสอบถามข้อมูลของผู้ใช้บางราย
สถานการณ์ทั่วไป: SELECT * FROM user_list โดยที่ชื่อผู้ใช้=xxx และรหัสผ่าน=xxx; (xxx ที่นี่ควรกรอกชื่อผู้ใช้และรหัสผ่านของผู้ใช้เอง)
สถานการณ์การฉีด: SELECT * FROM user_list โดยที่ชื่อผู้ใช้='abc' หรือ 1=1 -- รหัสผ่าน=xxx;
ด้วยวิธีนี้ 1=1 จะเท่ากัน และเพิ่มเครื่องหมาย "--" หน้ารหัสผ่าน และเนื้อหาต่อไปนี้จะกลายเป็นความคิดเห็นและจะไม่ถูกดำเนินการ กล่าวอีกนัยหนึ่ง สามารถสอบถามข้อมูลผู้ใช้ทั้งหมดได้โดยไม่ต้องใช้รหัสผ่าน
PreparedStatement เนื่องจากระบุพารามิเตอร์ในคำสั่ง SQL จึงสามารถป้องกันการแทรกได้
สรุป: ขอแนะนำให้ใช้ ReadyStatement เนื่องจากเร็วกว่าและปลอดภัยกว่า
7. ใช้ CallableStatement เพื่อดำเนินการตามขั้นตอนที่เก็บไว้
การใช้ CallableStatement จะดำเนินการตามขั้นตอนที่เก็บไว้เท่านั้น ในการสร้างขั้นตอนที่เก็บไว้ เรายังคงต้องสร้างขั้นตอนเหล่านั้นในฐานข้อมูล
ขั้นตอนที่ 1
ขณะนี้ฐานข้อมูลได้สร้างขั้นตอนการจัดเก็บแล้ว:
คัดลอกรหัสรหัสดังต่อไปนี้: DELIMITER $
สร้างขั้นตอน pro_add (ใน INT , ใน b VARCHAR (20), OUT c INT)
เริ่ม
SELECT * จากเรื่องโดยที่ sjid=a หรือ sjname=b;
SET c=a+a+a+a;
สิ้นสุด $
ขั้นตอนที่ 2
ใช้โค้ด Java เพื่อดำเนินการและรับพารามิเตอร์เอาต์พุต คัดลอกโค้ดดังนี้: @Test
โมฆะสาธารณะ calaST () พ่นข้อยกเว้น {
//รับการเชื่อมต่อ
การเชื่อมต่อ= sqlUtil.getconnection();
//เตรียมคำสั่ง SQL
สตริง sql = "CALL pro_add(?,?,?)";
// รับวัตถุ callableStatement
CallableStatement cbs = การเชื่อมต่อ.prepareCall(sql);
//ตั้งค่าพารามิเตอร์อินพุตเหมือนกับที่เตรียมไว้
cbs.setInt(1, 3);
cbs.setString(2, "คณิตศาสตร์");
/*แล้วจะตั้งค่าพารามิเตอร์เอาท์พุตได้อย่างไร?
* จำเป็นต้องลงทะเบียนพารามิเตอร์เอาต์พุต!
-
cbs.registerOutParameter(3, java.sql.Types.INTEGER);//คุณต้องใช้วัตถุในตัวเพื่อตั้งค่าประเภทพารามิเตอร์
//ดำเนินการคำสั่ง SQL
cbs.executeQuery();
//ใช้เมธอด getXXX เพื่อรับพารามิเตอร์เอาต์พุตของตำแหน่งที่เกี่ยวข้อง
จำนวนเต็ม num= cbs.getInt(3);
System.out.println("a*4 is " + num);
//ปิดทรัพยากร
sqlUtil.close(cbs, การเชื่อมต่อ);
-
ฉันหวังว่าบทความนี้จะเป็นประโยชน์กับการเขียนโปรแกรม Java ของทุกคน