ฉันไม่จำเป็นต้องหารือว่าทำไมการใช้รหัสซ้ำจึงมีประโยชน์ การใช้รหัสซ้ำมักจะทำให้การพัฒนาโปรแกรมเร็วขึ้นและลดข้อบกพร่อง เมื่อมีการห่อหุ้มรหัสและนำกลับมาใช้ใหม่แล้วจำเป็นต้องตรวจสอบรหัสชิ้นเล็ก ๆ เพื่อให้แน่ใจว่าถูกต้องของโปรแกรม หากคุณต้องการเปิดและปิดการเชื่อมต่อฐานข้อมูลในที่เดียวตลอดทั้งแอปพลิเคชันมันง่ายกว่ามากที่จะตรวจสอบให้แน่ใจว่าการเชื่อมต่อเป็นเรื่องปกติ แต่ฉันแน่ใจว่าคุณรู้ทั้งหมดนี้แล้ว
มีรหัสการนำกลับมาใช้ซ้ำสองประเภทซึ่งฉันเรียกว่าประเภทการใช้ซ้ำ:
ประเภทแรกคือการใช้ซ้ำการใช้งานซึ่งเป็นประเภทของการใช้ซ้ำที่พบบ่อยที่สุด นี่เป็นความเชี่ยวชาญสำหรับนักพัฒนาส่วนใหญ่ นั่นคือการนำชุดคำแนะนำที่ตามมากลับมาใช้ใหม่เพื่อดำเนินการบางอย่าง
ประเภทที่สองคือการใช้บริบทซ้ำนั่นคือฟังก์ชั่นที่แตกต่างกันหรือรหัสการทำงานถูกห่อหุ้มระหว่างบริบทเดียวกันและบริบทเดียวกันจะถูกห่อหุ้มเป็นรหัสนำกลับมาใช้ซ้ำ (บริบทที่นี่หมายถึงชุดของคำแนะนำการดำเนินการเดียวกัน) แม้ว่ามันจะกลายเป็นที่นิยมมากขึ้นในการกลับรายการควบคุม แต่ก็ไม่ได้เป็นเรื่องธรรมดา ยิ่งไปกว่านั้นการใช้บริบทซ้ำไม่ได้อธิบายไว้อย่างชัดเจนดังนั้นจึงไม่ได้ใช้โดยระบบเช่นการใช้ซ้ำการทำงาน ฉันหวังว่าคุณจะเปลี่ยนหลังจากอ่านบทความนี้
ใช้ฟังก์ชันซ้ำ
การใช้ซ้ำการใช้งานเป็นประเภทของการใช้ซ้ำที่พบบ่อยที่สุด มันเป็นการใช้ชุดคำสั่งที่ดำเนินการบางอย่างซ้ำ สองวิธีต่อไปนี้คือการอ่านข้อมูลจากฐานข้อมูล:
รายการสาธารณะ readAllusers () {การเชื่อมต่อการเชื่อมต่อ = null; String SQL = "SELECT * จากผู้ใช้"; ผู้ใช้รายการ = new ArrayList (); ลอง {connection = openConnection (); คำสั่ง PreparedStatement = Connection.prepareStatement (SQL); Resultset results = stement.executeQuery (); ในขณะที่ (result.next ()) {// ผู้ใช้รหัสนำใช้ซ้ำผู้ใช้ = ผู้ใช้ใหม่ (); user.setName (result.getString ("ชื่อ")); user.setEmail (result.getString ("อีเมล")); users.add (ผู้ใช้); // สิ้นสุดการใช้รหัสซ้ำ} result.close (); คำสั่ง close (); ผู้ใช้ที่ส่งคืน; } catch (sqlexception e) {// ละเว้นสำหรับตอนนี้} ในที่สุด {// ละเว้นสำหรับตอนนี้}} รายการสาธารณะ readusersofstatus (สถานะสตริง) {การเชื่อมต่อการเชื่อมต่อ = null; String sql = "เลือก * จากผู้ใช้ที่สถานะ =?"; ผู้ใช้รายการ = new ArrayList (); ลอง {connection = openConnection (); คำสั่ง PreparedStatement = Connection.prepareStatement (SQL); คำสั่ง SetString (1, สถานะ); Resultset results = stement.executeQuery (); ในขณะที่ (result.next ()) {// ผู้ใช้รหัสนำใช้ซ้ำผู้ใช้ = ผู้ใช้ใหม่ (); user.setName (result.getString ("ชื่อ")); user.setEmail (result.getString ("อีเมล")); users.add (ผู้ใช้); // สิ้นสุดการใช้รหัสซ้ำ} result.close (); คำสั่ง close (); ผู้ใช้ที่ส่งคืน; } catch (sqlexception e) {// ละเว้นสำหรับตอนนี้} ในที่สุด {// ละเว้นสำหรับตอนนี้}}สำหรับนักพัฒนาที่มีประสบการณ์อาจเป็นไปได้ที่จะค้นพบรหัสที่นำกลับมาใช้ใหม่ได้ในไม่ช้า สถานที่ที่ "รหัสนำกลับมาใช้ใหม่" แสดงความคิดเห็นในรหัสด้านบนเหมือนกันดังนั้นจึงสามารถนำมาใช้ซ้ำได้ นี่คือการดำเนินการที่อ่านบันทึกผู้ใช้เป็นอินสแตนซ์ผู้ใช้ บรรทัดของรหัสเหล่านี้สามารถห่อหุ้มเป็นวิธีการของตนเองได้เช่น:
// ห่อหุ้มการดำเนินการเดียวกันลงในวิธีการอ่านผู้ใช้ส่วนตัวผู้ใช้ผู้ใช้ (ผลลัพธ์ชุดผลลัพธ์) พ่น SQLException {ผู้ใช้ผู้ใช้ = ผู้ใช้ใหม่ (); user.setName (result.getString ("ชื่อ")); user.setEmail (result.getString ("อีเมล")); users.add (ผู้ใช้); ผู้ใช้ส่งคืน; -ตอนนี้เรียกใช้วิธีการอ่าน () ในสองวิธีข้างต้น (ตัวอย่างต่อไปนี้แสดงเฉพาะวิธีแรก):
รายการสาธารณะ readAllusers () {การเชื่อมต่อการเชื่อมต่อ = null; String SQL = "SELECT * จากผู้ใช้"; ผู้ใช้รายการ = new ArrayList (); ลอง {connection = openConnection (); คำสั่ง PreparedStatement = Connection.prepareStatement (SQL); Resultset results = stement.executeQuery (); ในขณะที่ (result.next ()) {users.add (readuser (ผลลัพธ์))} result.close (); คำสั่ง close (); ผู้ใช้ที่ส่งคืน; } catch (sqlexception e) {// ละเว้นสำหรับตอนนี้} ในที่สุด {// ละเว้นสำหรับตอนนี้}}วิธีการอ่าน () ยังสามารถซ่อนอยู่ในชั้นเรียนของตัวเองโดยใช้ตัวดัดแปลงส่วนตัว
ข้างต้นเป็นเรื่องเกี่ยวกับการใช้ฟังก์ชั่นซ้ำ การใช้ซ้ำการใช้งานคือการห่อหุ้มชุดคำสั่งที่ดำเนินการเฉพาะผ่านวิธีการหรือคลาสเพื่อให้บรรลุวัตถุประสงค์ในการใช้ซ้ำ
การดำเนินการพารามิเตอร์
บางครั้งคุณต้องการนำชุดปฏิบัติการกลับมาใช้ซ้ำ แต่การดำเนินการเหล่านี้ไม่เหมือนกันทุกที่ที่คุณใช้ ตัวอย่างเช่นวิธี readAllusers () และ readusersofstatus () ทั้งเปิดการเชื่อมต่อเตรียมคำสั่งดำเนินการและวนลูปผ่านชุดผลลัพธ์ ความแตกต่างเพียงอย่างเดียวคือ ReadusersofStatus () ต้องการพารามิเตอร์ที่จะตั้งค่าในการเตรียมการ เราสามารถห่อหุ้มการดำเนินการทั้งหมดลงในวิธี readuserList () ดังที่แสดงด้านล่าง:
รายการส่วนตัว readUserList (String SQL, String [] พารามิเตอร์) {การเชื่อมต่อการเชื่อมต่อ = null; ผู้ใช้รายการ = new ArrayList (); ลอง {connection = openConnection (); คำสั่ง PreparedStatement = Connection.prepareStatement (SQL); สำหรับ (int i = 0; i <parameters.length; i ++) {stement.setstring (i, พารามิเตอร์ [i]); } resultset results = stement.executeQuery (); ในขณะที่ (result.next ()) {users.add (readuser (ผลลัพธ์))} result.close (); คำสั่ง close (); ผู้ใช้ที่ส่งคืน; } catch (sqlexception e) {// ละเว้นสำหรับตอนนี้} ในที่สุด {// ละเว้นสำหรับตอนนี้}} ตอนนี้เราเรียกวิธี readUserList(...) จาก readAllUsers() และ readUsersOfStatus() และให้พารามิเตอร์การทำงานที่แตกต่างกัน:
รายการสาธารณะ readAllusers () {return readUserList ("เลือก * จากผู้ใช้", สตริงใหม่ [] {});} รายการสาธารณะ readuserswithStatus (สถานะสตริง) {return readUserList ("เลือก * จากผู้ใช้", สตริงใหม่ [] {สถานะ});ฉันเชื่อว่าคุณสามารถค้นหาวิธีที่ดีกว่าอื่น ๆ ในการใช้ฟังก์ชั่นนำกลับมาใช้ใหม่และกำหนดพารามิเตอร์เพื่อให้ใช้งานได้ง่ายขึ้น
นำบริบทมาใช้ซ้ำ
การใช้บริบทใหม่นั้นแตกต่างจากการใช้ฟีเจอร์ซ้ำเล็กน้อย การใช้บริบทซ้ำเป็นการใช้ซ้ำชุดคำสั่งและการดำเนินการต่าง ๆ จะดำเนินการระหว่างคำแนะนำเหล่านี้เสมอ กล่าวอีกนัยหนึ่งนำข้อความกลับมาใช้ใหม่ก่อนและหลังพฤติกรรมต่างๆ ดังนั้นบริบทการใช้ซ้ำมักจะนำไปสู่การผกผันของคลาสสไตล์การควบคุม การใช้บริบทซ้ำเป็นวิธีที่มีประสิทธิภาพมากในการใช้การจัดการข้อยกเว้นการเชื่อมต่อและการจัดการวงจรชีวิตการทำธุรกรรมการวนซ้ำและการปิดระบบและบริบทการดำเนินงานทั่วไปอื่น ๆ อีกมากมาย
นี่คือสองวิธีที่ทำด้วย InputStream:
โมฆะสาธารณะ printstream (inputstream inputstream) พ่น ioexception {ถ้า (inputstream == null) return; ข้อยกเว้น ioException = null; ลอง {int character = inputStream.read (); ในขณะที่ (ตัวละคร! = -1) {system.out.print ((ถ่าน) อักขระ); // อักขระที่แตกต่างกัน = inputStream.read (); }} ในที่สุด {ลอง {inputStream.close (); } catch (ioexception e) {ถ้า (exception == null) โยน e; }}} สตริงสาธารณะ readStream (inputStream inputStream) พ่น IOException {StringBuffer buffer = new StringBuffer (); // แตกต่างกันถ้า (inputStream == null) return; ข้อยกเว้น ioException = null; ลอง {int character = inputStream.read (); ในขณะที่ (ตัวละคร! = -1) {buffer.append ((ถ่าน) อักขระ); // อักขระที่แตกต่างกัน = inputStream.read (); } return buffer.toString (); // แตกต่าง} ในที่สุด {ลอง {inputStream.close (); } catch (ioexception e) {ถ้า (exception == null) โยน e; -ทั้งสองวิธีแตกต่างจากการทำงานของการไหล แต่บริบทรอบการดำเนินการเหล่านี้ก็เหมือนกัน รหัสบริบทวนซ้ำและปิดอินพุตสตรีม นอกเหนือจากความแตกต่างในการใช้เครื่องหมายความคิดเห็นแล้วรหัสข้างต้นคือรหัสบริบท
ดังที่แสดงไว้ข้างต้นบริบทเกี่ยวข้องกับการจัดการข้อยกเว้นและทำให้มั่นใจได้ว่าสตรีมจะปิดอย่างถูกต้องหลังจากการวนซ้ำ การเขียนการจัดการข้อผิดพลาดและรหัสการเปิดตัวทรัพยากรอีกครั้งและอีกครั้งนั้นยุ่งยากและผิดพลาดได้ง่าย การจัดการข้อผิดพลาดและการจัดการการเชื่อมต่อที่ถูกต้องมีความซับซ้อนมากขึ้นในการทำธุรกรรม JDBC เห็นได้ชัดว่ามันง่ายกว่าที่จะเขียนโค้ดหนึ่งครั้งและนำกลับมาใช้ใหม่ได้ทุกที่
โชคดีที่วิธีการห่อหุ้มบริบทนั้นง่าย สร้างคลาสบริบทและใส่บริบทสาธารณะลงไป ในการใช้บริบทคำแนะนำการดำเนินการที่แตกต่างกันจะถูกแยกออกไปในส่วนต่อประสานการดำเนินงานจากนั้นการดำเนินการแต่ละครั้งจะถูกห่อหุ้มในคลาสที่ใช้อินเตอร์เฟสการดำเนินการ (เรียกว่าคลาสการดำเนินการที่นี่) คุณจะต้องแทรกอินสแตนซ์ของคลาสการดำเนินการลงในบริบท มันสามารถทำได้โดยการผ่านอินสแตนซ์ของคลาสการดำเนินการเป็นพารามิเตอร์ไปยังตัวสร้างของวัตถุบริบทหรือโดยผ่านอินสแตนซ์ของคลาสการดำเนินการเป็นพารามิเตอร์ไปยังวิธีการดำเนินการเฉพาะของบริบท
ต่อไปนี้แสดงวิธีแยกตัวอย่างข้างต้นออกเป็นบริบทและอินเทอร์เฟซการดำเนินงาน StreamProcessor (อินเทอร์เฟซการดำเนินการ) ถูกส่งผ่านเป็นพารามิเตอร์ไปยังวิธี ProcessStream () ของ StreamProcessorContext
// สตรีมการประมวลผลปลั๊กอินอินเทอร์เฟซส่วนต่อประสานสาธารณะ StreamProcessor {กระบวนการโมฆะสาธารณะ (อินพุต int);} // สตรีมการประมวลผลบริบทคลาสคลาสสาธารณะ StreamProcessorContext {// อินเทอร์เฟซการทำงานของ StreamProcessor และทำหน้าที่เป็นพารามิเตอร์สาธารณะ ข้อยกเว้น ioException = null; ลอง {int character = inputStream.read (); ในขณะที่ (ตัวละคร! = -1) {processor.process (ตัวละคร); อักขระ = inputStream.read (); }} ในที่สุด {ลอง {inputStream.close (); } catch (ioexception e) {ถ้า (exception == null) โยน e; โยนข้อยกเว้น; -ตอนนี้คุณสามารถใช้คลาส StreamProcessorContext เพื่อพิมพ์เนื้อหาสตรีมเช่นตัวอย่างต่อไปนี้:
fileInputStream inputStream = new FileInputStream ("myFile"); // ตัวอย่างของการดำเนินการผ่านการใช้งาน subclass แบบไม่ระบุชื่อของอินเตอร์เฟส StreamProcessor ใหม่ StreamProcessorContext (). ProcessStream (อินพุตสตรีมใหม่)หรืออ่านเนื้อหาสตรีมอินพุตเช่นนี้และเพิ่มลงในลำดับอักขระ:
Public Class StreamToStringReader ใช้ StreamProcessor {Private StringBuffer Buffer = new StringBuffer (); Public StringBuffer GetBuffer () {return this.buffer; } กระบวนการโมฆะสาธารณะ (อินพุต int) {this.buffer.append ((ถ่าน) อินพุต); }} fileInputStream inputStream = new FileInputStream ("myFile"); StreamToStringReader reader = ใหม่ StreamToStringReader (); StreamProcessorContext ใหม่ (). processStream (inputStream, reader); // ทำอะไรบางอย่างอย่างที่คุณเห็นทำทุกอย่างด้วยสตรีมโดยการแทรกการใช้งานอินเตอร์เฟส StreamProcessor ที่แตกต่างกัน เมื่อมีการใช้งาน StreamProcessorContext อย่างเต็มที่คุณจะไม่มีปัญหาใด ๆ กับสตรีมที่ไม่ได้เปิด
การใช้บริบทซ้ำมีประสิทธิภาพมากและสามารถใช้ในสภาพแวดล้อมอื่น ๆ อีกมากมายนอกการประมวลผลสตรีม กรณีการใช้งานที่ชัดเจนคือการจัดการการเชื่อมต่อฐานข้อมูลและธุรกรรมอย่างถูกต้อง ( open - process - commit()/rollback() - close() ) กรณีการใช้งานอื่น ๆ คือการประมวลผลช่องสัญญาณ NIO และการซิงโครไนซ์เธรดในส่วนวิกฤต ( lock() - access shared resource - unlock() ) นอกจากนี้ยังสามารถแปลงข้อยกเว้นที่ตรวจสอบจาก API เป็นข้อยกเว้นที่ไม่ได้ตรวจสอบ
เมื่อคุณมองหารหัสที่เหมาะสมสำหรับการใช้บริบทซ้ำในโครงการของคุณให้มองหาโหมดการทำงานต่อไปนี้:
เมื่อคุณพบรูปแบบดังกล่าวการดำเนินการปกติก่อนและหลังอาจนำบริบทมาใช้ซ้ำ
บริบทเป็นวิธีเทมเพลต
บางครั้งคุณจะต้องมีปลั๊กอินหลายจุดในบริบท หากบริบทประกอบด้วยขั้นตอนที่เล็กกว่ามากมายและคุณต้องการให้แต่ละขั้นตอนของบริบทสามารถปรับแต่งได้คุณสามารถใช้บริบทเป็นวิธีเทมเพลต วิธีการเทมเพลตเป็นรูปแบบการออกแบบ GOF โดยทั่วไปวิธีการแม่แบบจะแบ่งอัลกอริทึมหรือโปรโตคอลออกเป็นชุดของขั้นตอน วิธีการเทมเพลตมักจะใช้เป็นคลาสฐานเดียวและให้วิธีการสำหรับแต่ละขั้นตอนในอัลกอริทึมหรือโปรโตคอล ในการปรับแต่งขั้นตอนใด ๆ เพียงแค่สร้างคลาสที่ขยายคลาสพื้นฐานของเทมเพลตและแทนที่วิธีการของขั้นตอนที่คุณต้องการปรับแต่ง
ตัวอย่างต่อไปนี้คือ JDBCCONTEXT ที่ใช้เป็นวิธีเทมเพลต คลาสย่อยสามารถแทนที่การเปิดและปิดการเชื่อมต่อเพื่อให้พฤติกรรมที่กำหนดเอง วิธี ProcessRecord (ผลลัพธ์ชุดผลลัพธ์) จะต้องถูกแทนที่เสมอเพราะเป็นนามธรรม วิธีนี้ให้การดำเนินการที่ไม่ได้อยู่ในบริบทและแตกต่างกันในกรณีที่แตกต่างกันโดยใช้ JDBCCONTEXT ตัวอย่างนี้ไม่ใช่ JDBCCONTEXT ที่สมบูรณ์แบบ มันถูกใช้เพื่อสาธิตวิธีการใช้วิธีการเทมเพลตเมื่อใช้บริบท
บทคัดย่อระดับสาธารณะ JDBCCONTEXT {DataSource DataSource = NULL; // ตัวสร้างที่ไม่มีพารามิเตอร์สามารถใช้สำหรับ subclasses โดยไม่ต้อง DataSource เพื่อรับการเชื่อมต่อสาธารณะ jdbccontext () {} jdbccontext สาธารณะ (แหล่งข้อมูล DataSource) {this.datasource = dataSource; } การเชื่อมต่อการเชื่อมต่อ openConnection () พ่น sqlexception {return dataSource.getConnection (); } การป้องกันโมฆะ closeconnection (การเชื่อมต่อการเชื่อมต่อ) พ่น sqlexception {connection.close (); } // processRecord (ผลลัพธ์ชุดผลลัพธ์) วิธีการป้องกันบทคัดย่อ processRecord (ผลลัพธ์ชุดผลลัพธ์) โยน sqlexception; โมฆะสาธารณะดำเนินการ (String SQL, Object [] พารามิเตอร์) พ่น sqlexception {การเชื่อมต่อการเชื่อมต่อ = null; คำสั่ง PreparedStatement = NULL; ผลลัพธ์ชุดผลลัพธ์ = null; ลอง {connection = openConnection (); คำสั่ง = การเชื่อมต่อการเตรียมการ (SQL); สำหรับ (int i = 0; i <parameters.length; i ++) {stement.setObject (i, พารามิเตอร์ [i]); } result = stement.executeQuery (); ในขณะที่ (result.next ()) {processRecord (ผลลัพธ์); }} ในที่สุด {ถ้า (ผลลัพธ์! = null) {ลอง {result.close (); } catch (sqlexception e) { / * ละเว้น * /}} ถ้า (คำสั่ง! = null) {ลอง {stement.close (); } catch (sqlexception e) { / * ละเว้น * /}} ถ้า (คำสั่ง! = null) {ลอง {stement.close (); } catch (sqlexception e) { / * ละเว้น * /}} ถ้า (การเชื่อมต่อ! = null) {closeconnection (การเชื่อมต่อ); -นี่คือคลาสย่อยที่ขยาย JDBCCONTEXT เพื่ออ่านรายการผู้ใช้:
ผู้อ่านคลาสสาธารณะขยาย JDBCCONTEXT {ผู้ใช้รายการ = new ArrayList (); ผู้อ่านสาธารณะ (DataSource DataSource) {Super (DataSource); } รายการสาธารณะ getusers () {return this.users; } void processRecord ที่ได้รับการป้องกัน (ผลลัพธ์ชุดผลลัพธ์) {ผู้ใช้ผู้ใช้ = ผู้ใช้ใหม่ (); user.setName (result.getString ("ชื่อ")); user.setEmail (result.getString ("อีเมล")); users.add (ผู้ใช้); -นี่คือวิธีการใช้คลาสผู้อ่าน:
ผู้อ่าน readusers = ผู้อ่านใหม่ (DataSource); readusers.execute ("เลือก * จากผู้ใช้", วัตถุใหม่ [0]); list users = readusers.getUsers (); หากคลาส Readusers จำเป็นต้องได้รับการเชื่อมต่อจากกลุ่มการเชื่อมต่อและปล่อยกลับไปที่พูลการเชื่อมต่อหลังการใช้งานคุณสามารถแทรกการเชื่อมต่อโดยการแทนที่ openConnection() และ closeConnection(Connection connection)
หมายเหตุวิธีเขียนรหัสการทำงานแทรกผ่านวิธีการ คลาสย่อยของ JDBCCONTEXT จะแทนที่วิธี ProcessRecord เพื่อให้การประมวลผลบันทึกพิเศษ ในตัวอย่าง StreamContext รหัสการทำงานจะถูกห่อหุ้มในวัตถุแยกต่างหากและมีให้เป็นพารามิเตอร์วิธีการ วัตถุที่ใช้อินเตอร์เฟสการดำเนินการ StreamProcessor จะถูกส่งผ่านเป็นพารามิเตอร์ไปยังเมธอด ProcessStreamContext processStream(...)
คุณสามารถใช้เทคนิคทั้งสองเมื่อใช้บริบท คลาส JDBCCONTEXT สามารถส่งผ่านวัตถุ ConnectionOpener และ ConnectionCloser ที่ใช้อินเตอร์เฟสการดำเนินการเป็นพารามิเตอร์ไปยังวิธีการดำเนินการหรือเป็นพารามิเตอร์ของตัวสร้าง โดยส่วนตัวแล้วฉันชอบใช้วัตถุการดำเนินการแยกต่างหากและอินเทอร์เฟซการทำงานด้วยเหตุผลสองประการ ก่อนอื่นทำให้การทดสอบหน่วยการดำเนินงานง่ายขึ้นเพียงอย่างเดียว ประการที่สองมันทำให้รหัสการดำเนินการนำกลับมาใช้ซ้ำในหลายบริบท แน่นอนว่ารหัสการดำเนินการสามารถใช้ในหลายสถานที่ในรหัส แต่นี่เป็นเพียงข้อได้เปรียบ ท้ายที่สุดที่นี่เราแค่พยายามนำบริบทกลับมาใช้ใหม่ไม่ใช่การนำการดำเนินการกลับมาใช้ใหม่
บทสรุป
ตอนนี้คุณได้เห็นสองวิธีที่แตกต่างกันในการใช้รหัสซ้ำ คุณลักษณะคลาสสิกนำกลับมาใช้ใหม่และนำบริบทกลับมาใช้ใหม่น้อยลง หวังว่าบริบทจะนำกลับมาใช้ใหม่เป็นเรื่องธรรมดาเช่นเดียวกับการใช้ฟีเจอร์ซ้ำ การใช้บริบทซ้ำเป็นวิธีที่มีประโยชน์มากในการใช้รหัสนามธรรมจากรายละเอียดพื้นฐานของ API (เช่น JDBC, IO หรือ NIO API ฯลฯ ) โดยเฉพาะอย่างยิ่งหาก API มีทรัพยากรที่จำเป็นต้องจัดการ (เปิดและปิดรับและส่งคืน ฯลฯ )
การคงอยู่/ORM API, Mr.Persister ใช้การใช้บริบทซ้ำเพื่อให้ได้การเชื่อมต่ออัตโนมัติและการจัดการวงจรชีวิตการทำธุรกรรม วิธีนี้ผู้ใช้จะไม่ต้องกังวลเกี่ยวกับการเปิดหรือปิดการเชื่อมต่ออย่างถูกต้องหรือกระทำหรือย้อนกลับธุรกรรม Mr.Persister ให้บริบทที่ผู้ใช้สามารถแทรกการดำเนินงานของพวกเขา บริบทเหล่านี้มีหน้าที่รับผิดชอบในการเปิดปิดการกระทำและย้อนกลับ
กรอบฤดูใบไม้ผลิยอดนิยมมีการใช้บริบทซ้ำมากมาย ตัวอย่างเช่น Springs JDBC Abstraction นักพัฒนาฤดูใบไม้ผลิใช้เป็น "การพลิกกลับการควบคุม" นี่ไม่ใช่ประเภทการผกผันควบคุมเดียวที่ใช้โดยเฟรมเวิร์กสปริง คุณลักษณะหลักของสปริงคือโรงงานการฉีดยาพึ่งพาถั่วหรือ "บริบทแอปพลิเคชัน" การฉีดพึ่งพาเป็นอีกประเภทหนึ่งของการผกผันควบคุม
ข้างต้นคือฟังก์ชั่นและบริบทการนำรหัส Java กลับมาใช้ใหม่ซึ่งตัวแก้ไขแนะนำให้คุณรู้จัก ฉันหวังว่ามันจะเป็นประโยชน์กับคุณ หากคุณมีคำถามใด ๆ โปรดฝากข้อความถึงฉันและบรรณาธิการจะตอบกลับคุณทันเวลา ขอบคุณมากสำหรับการสนับสนุนเว็บไซต์ Wulin.com!