ใน Java สิ่งใดบ้างที่มีการตรวจสอบข้อยกเว้นที่ดีสำหรับ [ปิด]

ข้อยกเว้นที่ตรวจสอบของ Java ได้รับการกดที่ไม่ดีในช่วงหลายปีที่ผ่านมา สัญญาณบอกคือมันเป็นภาษาเดียวในโลกที่มี (ไม่ใช่ภาษา JVM อื่น ๆ เช่น Groovy และ Scala) ไลบรารี Java ที่มีชื่อเสียงเช่น Spring และ Hibernate ก็ไม่ควรใช้

ฉันพบการใช้งานส่วนตัวสำหรับพวกเขา ( ในตรรกะทางธุรกิจระหว่างเลเยอร์) แต่อย่างอื่นฉันก็ค่อนข้างยกเว้นการตรวจสอบการต่อต้าน

มีการใช้งานอื่นที่ฉันไม่เข้าใจหรือไม่?

ก่อนอื่นเช่นกระบวนทัศน์การเขียนโปรแกรมอื่น ๆ ที่คุณต้องทำให้ถูกต้องเพื่อให้ทำงานได้ดี

สำหรับฉันข้อได้เปรียบของการตรวจสอบข้อยกเว้นคือผู้เขียนไลบรารีรันไทม์ Java ได้ตัดสินใจแล้วสำหรับฉันว่าปัญหาทั่วไปที่ฉันคาดว่าจะสามารถจัดการได้ ณจุดที่เรียก (ตรงข้ามกับ catch-print ระดับบนสุด) บล็อกตาย) และพิจารณาให้เร็วที่สุดวิธีจัดการกับปัญหาเหล่านี้

ฉันชอบการตรวจสอบข้อยกเว้นเพราะมันทำให้รหัสของฉันแข็งแกร่งขึ้นโดยบังคับให้ฉันคิดถึงการกู้คืนข้อผิดพลาดเร็วที่สุด

เพื่อความแม่นยำยิ่งขึ้นสำหรับฉันนี่ทำให้รหัสของฉันแข็งแกร่งขึ้นเนื่องจากบังคับให้ฉันต้องพิจารณากรณีมุมแปลก ๆ ในช่วงต้นของกระบวนการซึ่งต่างจากการพูดว่า "โอ๊ะโอรหัสของฉันไม่ได้จัดการหากไฟล์ยังไม่มีอยู่" ข้อผิดพลาดในการผลิตซึ่งคุณจะต้องทำงานซ้ำรหัสเพื่อจัดการ การเพิ่มข้อผิดพลาดในการจัดการโค้ดที่มีอยู่อาจเป็นงานที่ไม่สำคัญและมีราคาแพงเมื่อมาถึงการบำรุงรักษาซึ่งต่างจากการทำเพียงตั้งแต่เริ่มต้น

อาจเป็นได้ว่าไฟล์ที่หายไปนั้นเป็นสิ่งที่ร้ายแรงและควรทำให้โปรแกรมขัดข้องเนื่องจากไฟ แต่คุณตัดสินใจด้วย

} catch (FileNotFoundException e) {
  throw new RuntimeException("Important file not present", e);
}

สิ่งนี้แสดงให้เห็นถึงผลข้างเคียงที่สำคัญมาก หากคุณปิดล้อมข้อยกเว้นคุณสามารถเพิ่มคำอธิบายที่จะไปใน stack-trace ! สิ่งนี้มีประสิทธิภาพอย่างมากเพราะคุณสามารถเพิ่มข้อมูลเกี่ยวกับเช่นชื่อไฟล์ที่หายไปหรือพารามิเตอร์ที่ส่งผ่านไปยังวิธีนี้หรือข้อมูลการวินิจฉัยอื่น ๆ และข้อมูลนั้นมีอยู่ในการติดตามสแต็กซึ่งบ่อยครั้งเป็นสิ่งเดียวที่คุณ รับเมื่อโปรแกรมขัดข้อง

ผู้คนอาจพูดว่า "เราสามารถทำสิ่งนี้ในดีบักเกอร์เพื่อทำซ้ำ" แต่ฉันพบว่าบ่อยครั้งที่ข้อผิดพลาดการผลิตไม่สามารถทำซ้ำได้ในภายหลังและเราไม่สามารถเรียกใช้ debuggers ในการผลิตได้ยกเว้นในกรณีที่น่ารังเกียจ

ข้อมูลเพิ่มเติมในการติดตามสแต็กของคุณจะดีขึ้น การตรวจสอบข้อยกเว้นช่วยให้ฉันได้รับข้อมูลในนั้นและก่อนกำหนด

แก้ไข: สิ่งนี้มีไว้สำหรับนักออกแบบห้องสมุดด้วย ห้องสมุดหนึ่งแห่งที่ฉันใช้เป็นประจำทุกวันมีข้อยกเว้นที่ตรวจสอบแล้วจำนวนมากซึ่งอาจได้รับการออกแบบให้ดีขึ้นทำให้ไม่น่าใช้

คุณได้คำตอบที่ดีสองข้อซึ่งอธิบายว่าข้อยกเว้นใดที่ตรวจสอบแล้วได้กลายเป็นจริง (+1 ทั้งคู่) แต่มันก็คุ้มค่าที่จะตรวจสอบสิ่งที่พวกเขาตั้งใจไว้ในทางทฤษฎีเพราะความตั้งใจนั้นคุ้มค่าจริง ๆ

ข้อยกเว้นที่ตรวจสอบมีจุดประสงค์เพื่อให้ภาษาปลอดภัยยิ่งขึ้น พิจารณาวิธีการง่ายๆเช่นการคูณจำนวนเต็ม คุณอาจคิดว่าประเภทผลลัพธ์ของวิธีนี้จะเป็นจำนวนเต็ม แต่ถ้าพูดอย่างเคร่งครัดผลลัพธ์จะเป็นจำนวนเต็มหรือมีข้อยกเว้นมากเกินไป พิจารณาผลจำนวนเต็มด้วยตัวเองเป็นชนิดส่งคืนของวิธีการที่ไม่ได้แสดงช่วงเต็มของฟังก์ชั่น

เมื่อมองในแง่นี้มันไม่เป็นความจริงเลยที่จะกล่าวว่าข้อยกเว้นที่ตรวจสอบแล้วไม่พบวิธีในภาษาอื่น พวกเขาไม่ได้ใช้รูปแบบที่ Java ใช้ ในแอปพลิเคชัน Haskell เป็นเรื่องปกติที่จะใช้ประเภทข้อมูลพีชคณิตเพื่อแยกความแตกต่างระหว่างฟังก์ชั่นที่สำเร็จและไม่สำเร็จ แม้ว่านี่จะไม่ใช่ข้อยกเว้น แต่ความตั้งใจนั้นเหมือนกันมากกับข้อยกเว้นที่ตรวจสอบ มันเป็น API ที่ออกแบบมาเพื่อบังคับให้ผู้ใช้ API จัดการกับทั้งสองกรณีที่ประสบความสำเร็จเช่น:

data Foo a =
     Success a
   | DidNotWorkBecauseOfA
   | DidNotWorkBecauseOfB

สิ่งนี้บอกโปรแกรมเมอร์ว่าฟังก์ชันนั้นมีสองผลลัพธ์ที่เป็นไปได้นอกเหนือจากความสำเร็จ

IMO การตรวจสอบข้อยกเว้นเป็นการใช้งานที่ไม่สมบูรณ์ของสิ่งที่อาจเป็นความคิดที่ดีพอสมควร (ภายใต้สถานการณ์ที่แตกต่างกันโดยสิ้นเชิง - แต่จริงๆแล้วไม่ใช่ความคิดที่ดีแม้แต่ในสถานการณ์ปัจจุบัน)

ความคิดที่ดีคือจะเป็นการดีถ้าให้คอมไพเลอร์ตรวจสอบว่าข้อยกเว้นทั้งหมดที่โปรแกรมมีศักยภาพในการโยนจะถูกจับได้ การนำข้อบกพร่องมาใช้คือการทำเช่นนั้น Java บังคับให้คุณจัดการกับข้อยกเว้นโดยตรงในชั้นใดก็ตามที่เรียกใช้สิ่งที่ประกาศว่าจะโยนข้อยกเว้นที่ตรวจสอบแล้ว หนึ่งในแนวคิดพื้นฐานที่สุด (และข้อดี) ของการจัดการข้อยกเว้นคือในกรณีที่เกิดข้อผิดพลาดจะอนุญาตให้เลเยอร์กลางของโค้ดที่ไม่มีส่วนเกี่ยวข้องกับข้อผิดพลาดใด ๆ เพื่อเพิกเฉยต่อการมีอยู่จริงของมัน การตรวจสอบข้อยกเว้น (ตามที่นำมาใช้ใน Java) ไม่อนุญาตให้ทำเช่นนั้นจึงทำลายข้อได้เปรียบที่สำคัญ (หลัก?) ของการจัดการข้อยกเว้นเริ่มต้นด้วย

ในทางทฤษฎีพวกเขาสามารถตรวจสอบข้อยกเว้นที่เป็นประโยชน์ได้โดยการบังคับใช้พวกเขาเฉพาะบนพื้นฐานของโปรแกรม - เช่นในขณะที่ "การสร้าง" โปรแกรมสร้างต้นไม้ของเส้นทางการควบคุมทั้งหมดในโปรแกรม โหนดต่าง ๆ ในทรีจะถูกใส่คำอธิบายประกอบด้วย 1) ข้อยกเว้นที่สามารถสร้างได้และ 2) ข้อยกเว้นที่สามารถจับได้ เพื่อให้มั่นใจว่าโปรแกรมนั้นถูกต้องคุณจะต้องเดินไปที่ต้นไม้เพื่อยืนยันว่าทุกข้อยกเว้นที่ถูกโยนในระดับใดก็ตามในต้นไม้นั้นถูกจับได้ในระดับที่สูงกว่าในต้นไม้

เหตุผลที่พวกเขาไม่ทำอย่างนั้น (ฉันเดาว่าต่อไป) คือการทำเช่นนั้นจะยากอย่างเลือดตาแทบกระเด็น - ในความเป็นจริงฉันสงสัยว่าใครเขียนระบบสร้างที่สามารถทำสิ่งใด ๆ แต่ง่ายมาก (ติดกับ "ของเล่น" ") ภาษา / ระบบ สำหรับ Java การโหลดคลาสแบบไดนามิกทำให้มันยากกว่าในกรณีอื่น ๆ ที่เลวร้ายยิ่งกว่า (ไม่เหมือนอะไรอย่าง C) Java ไม่ใช่ (อย่างน้อยปกติ) คอมไพล์แบบสแตติก / ลิงก์ไปยังไฟล์ที่เรียกทำงานได้ นั่นหมายความว่าไม่มีอะไรในระบบที่มีการรับรู้ทั่วโลกที่จะพยายามบังคับใช้เช่นนี้จนกว่าผู้ใช้จะเริ่มโหลดโปรแกรมเพื่อใช้งานจริง

การบังคับใช้ ณ จุดนั้นเป็นไปไม่ได้ด้วยเหตุผลสองประการ ก่อนอื่นที่ดีที่สุดมันจะขยายเวลาเริ่มต้นซึ่งเป็นหนึ่งในข้อร้องเรียนที่ใหญ่ที่สุดและพบบ่อยที่สุดเกี่ยวกับ Java ประการที่สองในการทำดีมากคุณต้องตรวจสอบปัญหาก่อนเพื่อให้โปรแกรมเมอร์สามารถแก้ไขได้ เมื่อผู้ใช้กำลังโหลดโปรแกรมมันก็สายเกินไปที่จะทำดีมาก - ตัวเลือกเดียวของคุณ ณ จุดนี้คือการเพิกเฉยต่อปัญหาหรือปฏิเสธที่จะโหลด / เรียกใช้โปรแกรมเลยในโอกาสที่อาจมีข้อยกเว้น ที่ไม่ได้ถูกจับ

เนื่องจากข้อผิดพลาดที่ตรวจสอบนั้นเลวร้ายยิ่งกว่าไร้ประโยชน์ แต่การออกแบบทางเลือกสำหรับข้อยกเว้นที่ตรวจสอบนั้นยิ่งแย่กว่าเดิม ในขณะที่แนวคิดพื้นฐานสำหรับข้อยกเว้นที่ตรวจสอบดูเหมือนจะเป็นแนวคิดที่ดี แต่ก็ไม่ค่อยดีนักและเป็นแบบที่ไม่ดีสำหรับ Java โดยเฉพาะ สำหรับบางอย่างเช่น C ++ ปกติแล้วจะถูกรวบรวม / เชื่อมโยงไปยังไฟล์ปฏิบัติการที่สมบูรณ์โดยไม่มีอะไรที่เหมือนกับการสะท้อน / การโหลดคลาสแบบไดนามิกคุณจะมีโอกาสเพิ่มขึ้นเล็กน้อย (แม้ว่าค่อนข้างตรงไปตรงมาแม้แต่บังคับใช้อย่างถูกต้อง ปัจจุบันสาเหตุใน Java จะยังคงเกินกว่าสถานะปัจจุบันของศิลปะ)

พวกเขาดีจริงๆสำหรับโปรแกรมเมอร์ที่น่ารำคาญและกระตุ้นการกลืนยกเว้น จุดยกเว้นครึ่งหนึ่งคือเพื่อให้คุณมีวิธีจัดการข้อผิดพลาดที่เป็นค่าเริ่มต้นและไม่ต้องคิดเกี่ยวกับการเผยแพร่เงื่อนไขข้อผิดพลาดที่คุณไม่สามารถจัดการได้ (ค่าเริ่มต้นมีสติอยู่ที่ถ้าคุณไม่เคยจัดการกับข้อผิดพลาดที่ใดก็ได้ในรหัสของคุณคุณยืนยันอย่างมีประสิทธิภาพว่ามันไม่สามารถเกิดขึ้นได้และถูกทิ้งไว้กับทางออกสติและกองติดตามถ้าคุณผิด) ตรวจสอบความพ่ายแพ้ข้อยกเว้น นี้. พวกเขารู้สึกเหมือนต้องเผยแพร่ข้อผิดพลาดใน C อย่างชัดเจน

ฉันคิดว่ามันยุติธรรมที่จะบอกว่าข้อยกเว้นที่ตรวจสอบนั้นเป็นบิตของการทดลองที่ล้มเหลว ที่ที่พวกเขาทำผิดคือพวกเขาทำลายการฝังรากลึก:

• โมดูล A อาจถูกสร้างขึ้นที่ด้านบนของโมดูล B ที่
• โมดูล B อาจถูกสร้างขึ้นที่ด้านบนของโมดูล C
• โมดูล C อาจทราบวิธีระบุข้อผิดพลาดและ
• โมดูล A อาจรู้วิธีจัดการกับข้อผิดพลาด

การแยกความกังวลออกมาเป็นเรื่องที่ดีเพราะตอนนี้ความรู้เกี่ยวกับข้อผิดพลาดที่อาจ จำกัด เฉพาะ A และ C ต้องกระจัดกระจายไปทั่ว B

มีการสนทนาที่ดีเกี่ยวกับข้อยกเว้นที่ถูกตรวจสอบใน Wikipedia

และ Bruce Eckel ก็มีบทความที่ดีเช่นกัน นี่คือคำพูด:

[T] เขาสุ่มกฎมากกว่าที่คุณพะเนินกับโปรแกรมเมอร์กฎที่ไม่มีอะไรเกี่ยวข้องกับการแก้ปัญหาในมือโปรแกรมเมอร์ที่ช้าลงก็สามารถผลิตได้ และนี่ไม่ปรากฏว่าเป็นปัจจัยเชิงเส้น แต่เป็นเลขยกกำลัง

ฉันเชื่อว่าในกรณีของ C ++ หากวิธีการทั้งหมดมีthrowsข้อกำหนดข้อคุณสามารถมีการเพิ่มประสิทธิภาพที่ดี ฉันไม่เชื่อว่า Java มีข้อได้เปรียบเหล่านั้นอยู่ดีเนื่องจากRuntimeExceptionsไม่ได้รับการตรวจสอบ JIT ที่ทันสมัยควรจะสามารถปรับรหัสให้เหมาะสมอยู่ดี

คุณลักษณะที่ดีอย่างหนึ่งของ AspectJ คือการทำให้ข้อยกเว้นอ่อนลง: คุณสามารถเปลี่ยนข้อยกเว้นที่ตรวจสอบแล้วให้เป็นข้อยกเว้นที่ไม่ได้ตรวจสอบได้

บางทีมันอาจเป็นเรื่องน่าขันที่ Java ได้เผชิญกับปัญหาทั้งหมดนี้เมื่อมันสามารถตรวจสอบได้nullแทนซึ่งอาจมีค่ามากกว่านี้

ฉันรักข้อยกเว้น

อย่างไรก็ตามฉันรู้สึกสับสนตลอดเวลาจากการใช้งานที่ไม่ได้ใช้

1. อย่าใช้มันสำหรับการควบคุมการไหล คุณไม่ต้องการโค้ดที่พยายามทำบางสิ่งบางอย่างและใช้ข้อยกเว้นเป็นตัวกระตุ้นให้ทำอย่างอื่นแทนเนื่องจากข้อยกเว้นคือวัตถุที่ต้องสร้างและใช้หน่วยความจำ ฯลฯ เป็นต้นเพียงเพราะคุณไม่สามารถเขียนบางอย่างได้ ชนิดของ if () ตรวจสอบก่อนที่จะทำการโทร นั่นเป็นเพียงสันหลังยาวและให้ชื่อยกเว้นอันรุ่งโรจน์เป็นชื่อที่ไม่ดี

2. อย่ากลืนพวกเขา เคย ไม่ว่าในกรณีใด ๆ อย่างน้อยที่สุดคุณก็ติดบางอย่างในล็อกไฟล์เพื่อระบุว่ามีข้อยกเว้นเกิดขึ้น พยายามติดตามวิธีการของคุณผ่านรหัสที่กลืนกินข้อยกเว้นเป็นฝันร้าย อีกครั้งสาปแช่งคุณข้อยกเว้นสำหรับนำข้อยกเว้นอันยิ่งใหญ่มาสู่ความเสียชื่อเสียง!

3. ทำข้อยกเว้นกับหมวก OO ของคุณ สร้างวัตถุยกเว้นของคุณเองด้วยลำดับชั้นที่มีความหมาย เลเยอร์ตรรกะทางธุรกิจของคุณและข้อยกเว้นของคุณจับมือกัน ฉันเคยพบว่าถ้าฉันเริ่มต้นในพื้นที่ใหม่ของระบบฉันจะพบความจำเป็นในการยกเว้นคลาสย่อยภายในครึ่งชั่วโมงของการเข้ารหัสดังนั้นวันนี้ฉันจึงเริ่มต้นด้วยการเขียนคลาสข้อยกเว้น

4. หากคุณกำลังเขียนบิต 'frameworky' ของโค้ดตรวจสอบให้แน่ใจว่าอินเทอร์เฟซเริ่มต้นทั้งหมดของคุณถูกเขียนเพื่อโยนข้อยกเว้นใหม่ของคุณเองตามความเหมาะสม ... และตรวจสอบให้แน่ใจว่าโคเดอร์ของคุณมีโค้ดตัวอย่างอยู่รอบ ๆ พ่น IOException แต่อินเทอร์เฟซที่พวกเขากำลังเขียนเพื่อต้องการโยน 'ReportingApplicationException'

เมื่อคุณครุ่นคิดถึงวิธีที่จะทำให้ข้อยกเว้นทำงานให้คุณคุณจะไม่มองย้อนกลับไป

ข้อยกเว้นที่ตรวจสอบอยู่ใน ADA

(คำเตือนโพสต์นี้มีความเชื่ออย่างยิ่งที่คุณอาจพบว่าต้องเผชิญ)

โปรแกรมเมอร์ไม่ชอบพวกเขาและบ่นหรือเขียนโค้ดการกลืนยกเว้น

มีการตรวจสอบข้อยกเว้นอยู่เนื่องจากสิ่งต่าง ๆ ไม่เพียง แต่ล้มเหลวในการทำงานเท่านั้นคุณสามารถทำการวิเคราะห์โหมดความล้มเหลว / เอฟเฟกต์และกำหนดสิ่งนี้ล่วงหน้า

การอ่านไฟล์อาจล้มเหลว การเรียก RPC อาจล้มเหลว เครือข่าย IO สามารถล้มเหลว ข้อมูลสามารถจัดรูปแบบผิดเมื่อแยกวิเคราะห์

"เส้นทางที่มีความสุข" สำหรับรหัสนั้นง่าย

ฉันรู้จักผู้ชายคนหนึ่งในมหาวิทยาลัยที่สามารถเขียนโค้ด "เส้นทางที่มีความสุข" ที่ยอดเยี่ยมได้ ไม่มีกรณีที่ขอบเคยทำงาน ทุกวันนี้เขาทำ Python สำหรับ บริษัท โอเพ่นซอร์ส Nuff กล่าวว่า.

หากคุณไม่ต้องการจัดการข้อยกเว้นที่เลือกไว้สิ่งที่คุณพูดจริงๆคือ

While I'm writing this code, I don't want to consider obvious failure modes.

The User will just have to like the program crashing or doing weird things.

But that's okay with me because 

I'm so much more important than the people who will have to use the software

in the real, messy, error-prone world.

After all, I write the code once, you use it all day long.

ดังนั้นการตรวจสอบข้อยกเว้นจะไม่ถูกชอบโดยโปรแกรมเมอร์เพราะมันหมายถึงการทำงานมากขึ้น

แน่นอนว่าคนอื่นอาจต้องการงานที่ทำ

พวกเขาอาจต้องการคำตอบที่ถูกต้องแม้ว่าไฟล์เซิร์ฟเวอร์จะล้มเหลว / USB stick ตาย

เป็นความเชื่อที่แปลกในชุมชนการเขียนโปรแกรมที่คุณควรใช้ภาษาการเขียนโปรแกรมที่ทำให้ชีวิตของคุณง่ายขึ้นที่คุณสนุกเมื่องานของคุณคือการเขียนซอฟต์แวร์ งานของคุณกำลังแก้ไขปัญหาบางคนไม่ให้คุณมีส่วนร่วมในการปรับแต่งโปรแกรมแบบแจ๊ส

หากคุณเป็นโปรแกรมเมอร์มือสมัครเล่น (ไม่ใช่การเขียนโปรแกรมเพื่อเงิน) อย่าลังเลที่จะเขียนโปรแกรมในภาษา C # หรือภาษาอื่นที่ไม่มีข้อยกเว้นที่ตรวจสอบ Heck ตัดชายกลางและโปรแกรมในโลโก้ คุณสามารถวาดลวดลายที่สวยงามบนพื้นด้วยเต่า

ข้อยกเว้นที่ตรวจสอบควรสนับสนุนให้คนจัดการข้อผิดพลาดใกล้กับแหล่งที่มา ยิ่งห่างจากแหล่งที่มายิ่งฟังก์ชั่นมากขึ้นจะถูกยกเลิกในระหว่างการทำงานและมีโอกาสมากที่ระบบจะเข้าสู่สถานะที่ไม่สอดคล้องกัน นอกจากนี้ยังมีแนวโน้มว่าคุณจะได้รับการยกเว้นที่ผิดโดยบังเอิญ

น่าเศร้าที่ผู้คนมักจะมองข้ามข้อยกเว้นหรือเพิ่มรายละเอียดการโยน ทั้งคู่พลาดจุดที่ควรได้รับการส่งเสริม พวกเขาเป็นเหมือนการแปลงรหัสขั้นตอนการใช้ฟังก์ชั่น Getter และ Setter ที่คาดคะเนว่าเป็น OO

โดยพื้นฐานแล้วข้อยกเว้นที่ถูกตรวจสอบกำลังพยายามพิสูจน์ระดับความถูกต้องในรหัสของคุณ มันเป็นแนวคิดแบบเดียวกับการพิมพ์แบบสแตติกในความพยายามที่จะพิสูจน์ว่าบางสิ่งถูกต้องก่อนที่โค้ดจะทำงาน ปัญหาคือหลักฐานทั้งหมดนั้นต้องใช้ความพยายามและคุ้มค่าหรือไม่