อะไรคือข้อเสียในการใช้การฉีดพึ่งพา? [ปิด]

ฉันพยายามที่จะแนะนำ DI เป็นรูปแบบที่นี่ในที่ทำงานและหนึ่งในนักพัฒนานำของเราต้องการทราบ: อะไร - ถ้ามี - มีข้อเสียในการใช้รูปแบบการฉีดพึ่งพาหรือไม่

หมายเหตุฉันกำลังมองหาที่ - ถ้าเป็นไปได้ - รายการที่ละเอียดถี่ถ้วนไม่ใช่การอภิปรายเชิงอัตนัยในหัวข้อ

ชี้แจง : ฉันกำลังพูดถึงรูปแบบการพึ่งพา(ดูบทความนี้โดย Martin Fowler) ไม่ใช่กรอบที่เฉพาะเจาะจงไม่ว่าจะเป็น XML (เช่นฤดูใบไม้ผลิ) หรือตามรหัส (เช่น Guice) หรือ "ม้วนตัวเอง" .

แก้ไข : บางการอภิปรายเพิ่มเติม / คุยโว / อภิปรายเกิดขึ้น/ r / การเขียนโปรแกรมที่นี่

คะแนนสองสาม:

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

โดยทั่วไปประโยชน์ของการแยกชิ้นงานทำให้แต่ละงานง่ายขึ้นในการอ่านและทำความเข้าใจ แต่เพิ่มความซับซ้อนของการเตรียมงานที่ซับซ้อนมากขึ้น

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

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

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

ลิงค์ที่เกี่ยวข้อง

http://thedailywtf.com/Articles/The_Inner-Platform_Effect.aspx

http://www.joelonsoftware.com/articles/fog0000000018.html

อาจเป็นรูปแบบที่ง่ายที่สุดของการฉีดพึ่งพา (อย่าหัวเราะ) เป็นพารามิเตอร์ รหัสที่ต้องพึ่งพานั้นขึ้นอยู่กับข้อมูลและข้อมูลนั้นถูกฉีดเข้าด้วยวิธีการส่งผ่านพารามิเตอร์

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

ให้ใช้ฟังก์ชั่นดั้งเดิมที่เรียบง่าย - ไวยากรณ์ C ++ ไม่ได้มีความหมายที่นี่

void Say_Hello_World ()
{
  std::cout << "Hello World" << std::endl;
}

ฉันมีการพึ่งพาที่ฉันต้องการแยกออกและฉีด - ข้อความ "Hello World" ง่ายพอ ...

void Say_Something (const char *p_text)
{
  std::cout << p_text << std::endl;
}

มีความยืดหยุ่นมากกว่าเดิมอย่างไร? ถ้าฉันตัดสินใจว่าเอาท์พุทควรเป็น Unicode ฉันอาจต้องการเปลี่ยนจาก std :: cout เป็น std :: wcout แต่นั่นหมายความว่าสายของฉันจะต้องเป็น wchar_t ไม่ใช่ของ char ไม่ว่าผู้โทรทุกคนจะต้องเปลี่ยนหรือ (มีเหตุผลมากกว่า) การใช้งานแบบเก่าจะถูกแทนที่ด้วยอะแดปเตอร์ที่แปลสตริงและเรียกการใช้งานใหม่

นั่นคืองานบำรุงรักษาที่นั่นซึ่งไม่จำเป็นหากเราเก็บต้นฉบับไว้

และถ้ามันดูไม่สำคัญลองดูที่ฟังก์ชั่นโลกแห่งความจริงจาก Win32 API ...

http://msdn.microsoft.com/en-us/library/ms632680%28v=vs.85%29.aspx

นั่นคือ 12 "การพึ่งพา" เพื่อจัดการกับ ตัวอย่างเช่นหากความละเอียดหน้าจอมีขนาดใหญ่มากเราอาจต้องใช้ค่าประสาน 64- บิตและ CreateWindowEx รุ่นอื่น และใช่แล้วยังมีเวอร์ชั่นเก่าที่ยังคงห้อยอยู่ซึ่งน่าจะถูกแมปกับเวอร์ชั่นใหม่กว่าเบื้องหลัง ...

http://msdn.microsoft.com/en-us/library/ms632679%28v=vs.85%29.aspx

"การพึ่งพา" เหล่านั้นไม่ได้เป็นเพียงปัญหาสำหรับนักพัฒนาดั้งเดิม - ทุกคนที่ใช้อินเทอร์เฟซนั้นต้องค้นหาว่าการอ้างอิงคืออะไรวิธีการที่พวกเขาระบุและสิ่งที่พวกเขาหมายถึงและหาสิ่งที่ต้องทำ นี่คือที่คำว่า "ค่าเริ่มต้นที่เหมาะสม" สามารถทำให้ชีวิตง่ายขึ้นมาก

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

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

นี่คือปฏิกิริยาเริ่มต้นของฉัน: โดยทั่วไปแล้วข้อเสียของรูปแบบใด ๆ

• มันต้องใช้เวลาในการเรียนรู้
• หากเข้าใจผิดอาจนำไปสู่อันตรายมากกว่าดี
• หากทำไปมากมันสามารถทำงานได้มากกว่าที่จะพิสูจน์ให้เห็นถึงประโยชน์

"ข้อเสีย" ที่ใหญ่ที่สุดของ Inversion of Control (ไม่ใช่ DI แต่อยู่ใกล้พอ) คือมันมีแนวโน้มที่จะลบจุดเดียวเพื่อดูภาพรวมของอัลกอริทึม นั่นเป็นสิ่งที่เกิดขึ้นเมื่อคุณถอดรหัสรหัสได้แล้ว - ความสามารถในการดูในที่เดียวคือสิ่งประดิษฐ์ของคลัปแน่น

ฉันไม่คิดว่ามีรายการดังกล่าวอยู่อย่างไรก็ตามพยายามอ่านบทความเหล่านี้:

• DI สามารถปิดบังรหัส (หากคุณไม่ได้ทำงานกับ IDE ที่ดี)

• การใช้ IoC ในทางที่ผิดสามารถนำไปสู่รหัสที่ไม่ดีตามลุงบ๊อบ

• จำเป็นต้องระวังวิศวกรรมมากเกินไปและสร้างความสามารถรอบตัวที่ไม่จำเป็น

ฉันใช้ Guice (Java DI Framework) อย่างกว้างขวางในช่วง 6 เดือนที่ผ่านมา แม้ว่าโดยรวมแล้วฉันคิดว่ามันยอดเยี่ยม (โดยเฉพาะจากมุมมองการทดสอบ) แต่ก็มีข้อเสียอยู่บ้าง สะดุดตาที่สุด:

• รหัสสามารถเข้าใจได้ยากขึ้น การฉีดพึ่งพาสามารถใช้ใน ... สร้างสรรค์ ... วิธี ตัวอย่างเช่นฉันเพิ่งเจอรหัสบางส่วนที่ใช้คำอธิบายประกอบที่กำหนดเองเพื่อฉีด IOStreams บางอย่าง (เช่น: @ Server1Stream, @ Server2Stream) ในขณะที่ใช้งานได้และฉันจะยอมรับว่ามีความสง่างามบางอย่างมันทำให้การทำความเข้าใจ Guice การฉีดจำเป็นต้องเข้าใจรหัส
• เส้นโค้งการเรียนรู้ที่สูงขึ้นเมื่อโครงงานเรียนรู้ สิ่งนี้เกี่ยวข้องกับประเด็นที่ 1 เพื่อที่จะเข้าใจว่าโครงการที่ใช้การฉีดแบบพึ่งพานั้นคุณต้องเข้าใจทั้งรูปแบบการฉีดแบบพึ่งพาและกรอบเฉพาะ เมื่อฉันเริ่มงานปัจจุบันของฉันฉันใช้เวลาไม่กี่ชั่วโมงที่สับสนในสิ่งที่ Guice กำลังทำอยู่เบื้องหลัง
• ตัวสร้างมีขนาดใหญ่ แม้ว่าสิ่งนี้สามารถแก้ไขได้ส่วนใหญ่ด้วยตัวสร้างเริ่มต้นหรือโรงงาน
• ข้อผิดพลาดสามารถทำให้งง ตัวอย่างล่าสุดของฉันนี้คือฉันมีการชนกันของชื่อธง 2 Guice กลืนข้อผิดพลาดอย่างเงียบ ๆ และหนึ่งในธงของฉันไม่ได้เริ่มต้น
• ข้อผิดพลาดถูกผลักไปที่เวลาทำงาน ถ้าคุณกำหนดค่าโมดูล Guice ของคุณอย่างไม่ถูกต้อง (การอ้างอิงแบบวงกลม, การรวมที่ไม่ถูกต้อง, ... ) ข้อผิดพลาดส่วนใหญ่จะไม่ถูกเปิดเผยในระหว่างการคอมไพล์เวลา แต่ข้อผิดพลาดจะปรากฏเมื่อโปรแกรมทำงานจริง

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

นอกจากนี้ฉันเห็นด้วยกับโปสเตอร์อื่น ๆ ที่สามารถใช้การฉีดพึ่งพาได้มากเกินไป

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

รหัสที่ DI ใช้บ่อยๆอาจเป็นรหัส Ravioliซึ่งแต่ละชั้นเรียนขนาดเล็กเป็นเหมือนนักเก็ตราวีโอลี่แต่ละคน - มันทำสิ่งเล็ก ๆ น้อย ๆ และยึดหลักความรับผิดชอบเดี่ยวซึ่งเป็นสิ่งที่ดี แต่การดูคลาสด้วยตัวเองมันยากที่จะเห็นว่าระบบโดยรวมทำอะไรเพราะสิ่งนี้ขึ้นอยู่กับว่าชิ้นส่วนเล็ก ๆ เหล่านี้เข้ากันได้ดีแค่ไหนซึ่งยากที่จะมองเห็น ดูเหมือนว่ามันเป็นกองเล็ก ๆ

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

ฉันไม่คิดว่านี่เป็นข้อเสียร้ายแรง - DI ยังมีค่ามาก ระดับราวีโอลี่สไตล์ที่มีชั้นเรียนขนาดเล็กที่ทำเพียงสิ่งเดียวอาจจะดี ยิ่งกว่านั้นฉันไม่คิดว่ามันจะแย่ไปกว่าปาเก็ตตี้ แต่การตระหนักว่าสามารถนำไปไกลเกินไปเป็นขั้นตอนแรกในการหลีกเลี่ยง ทำตามลิงก์สำหรับการอภิปรายเกี่ยวกับวิธีการหลีกเลี่ยง

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

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

เพื่อแสดงให้เห็นถึงจุดที่สองที่ดีกว่านี่คือข้อความที่ตัดตอนมาจากบทความนี้ ( ต้นฉบับดั้งเดิม ) ซึ่งฉันเชื่อว่าเป็นปัญหาพื้นฐานในการสร้างระบบใด ๆ ไม่ใช่แค่ระบบคอมพิวเตอร์

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

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

DI แก้ปัญหานี้ได้หรือไม่? ไม่ แต่มันจะช่วยให้คุณเห็นอย่างชัดเจนว่าคุณกำลังพยายามมอบหมายความรับผิดชอบในการออกแบบทุกห้องให้กับผู้อยู่อาศัยหรือไม่

สิ่งหนึ่งที่ทำให้ฉันดิ้นรนเล็กน้อยกับ DI คือข้อสันนิษฐานว่าวัตถุที่ถูกฉีดทั้งหมดมีราคาถูกในการสร้างอินสแตนซ์และไม่มีผลข้างเคียง - หรือ - การพึ่งพานั้นถูกใช้บ่อย ๆ

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

Public Class MyClass
    Private ReadOnly mExLogHandlerService As IExceptionLogHandlerService

    Public Sub New(exLogHandlerService As IExceptionLogHandlerService)
        Me.mExLogHandlerService = exLogHandlerService
    End Sub

     ...
End Class

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

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

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

ภาพลวงตาที่คุณถอดรหัสรหัสของคุณเพียงแค่ใช้การฉีดอ้างอิงโดยไม่ต้อง decoupling จริง ๆ ฉันคิดว่านั่นเป็นสิ่งที่อันตรายที่สุดเกี่ยวกับ DI

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

โดยเฉพาะอย่างยิ่งถ้าคุณควบคุมคลิก / Command-Click ในการร้องขอวิธีการในรหัสมันจะนำคุณไปสู่การประกาศวิธีการในส่วนติดต่อแทนการใช้งานที่เป็นรูปธรรม

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

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

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

Constructor-based injection พึ่งพา (โดยไม่ต้องอาศัยความช่วยเหลือของ "กรอบ") เป็นวิธีที่สะอาดและเป็นประโยชน์ในการสร้างรหัส OO ในฐานรหัสที่ดีที่สุดที่ฉันเคยเห็นมานานหลายปีใช้เวลากับอดีตเพื่อนร่วมงานของ Martin Fowler ฉันเริ่มสังเกตเห็นว่าชั้นเรียนที่ดีที่สุดที่เขียนด้วยวิธีนี้จบลงด้วยdoSomethingวิธีการเดียว

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

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

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

(ในฐานะ sidenote ฉันพบว่าหัวข้อทั้งหมดค่อนข้าง "ทางศาสนา" แต่ระยะของคุณจะแตกต่างกันไปตามระดับของความกระตือรือร้นด้านเทคนิคในทีมนักพัฒนาของคุณ!)

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

เช่นเดียวกับคำตอบของ Mark Seemann บรรทัดล่างคือคุณใช้เวลาในการเป็นนักพัฒนาซอฟต์แวร์ที่ดีกว่าการแฮ็ครหัสบิตด้วยกัน สิ่งที่ธุรกิจของคุณจะค่อนข้างมี? มีเพียงคุณเท่านั้นที่ตอบได้

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

หากคุณแนะนำ DI เป็นหลักการสำหรับแอปพลิเคชันรุ่นเก่าโดยใช้กรอบงาน - ความผิดพลาดที่ใหญ่ที่สุดเพียงข้อเดียวที่คุณสามารถทำได้คือการใช้งานผิดประเภทในฐานะ Service-Locater DI + Framework นั้นยอดเยี่ยมและทำให้ทุกอย่างดีขึ้นทุกที่ที่ฉันเห็น! จากมุมมองขององค์กรมีปัญหาทั่วไปเกี่ยวกับกระบวนการเทคนิครูปแบบใหม่ ... :

• คุณต้องฝึกทีมคุณ
• คุณต้องเปลี่ยนใบสมัครของคุณ (ซึ่งรวมถึงความเสี่ยง)

โดยทั่วไปคุณต้องลงทุนเวลาและเงินนอกจากนั้นไม่มีข้อเสียจริงๆ!

อ่านรหัสได้ คุณจะไม่สามารถเข้าใจโฟลว์โค้ดได้ง่ายเนื่องจากการอ้างอิงถูกซ่อนอยู่ในไฟล์ XML

สองสิ่ง:

• พวกเขาต้องการการสนับสนุนเครื่องมือพิเศษเพื่อตรวจสอบว่าการกำหนดค่านั้นถูกต้อง

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

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

• มันทำให้การวิเคราะห์แบบคงที่ทั่วโลกของโปรแกรมยากมาก

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

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

มันสามารถเพิ่มเวลาเริ่มต้นแอปได้เนื่องจากคอนเทนเนอร์ IoC ควรแก้ไขการพึ่งพาในวิธีที่เหมาะสมและบางครั้งต้องใช้การวนซ้ำหลายครั้ง