ปรับสมดุลการพึ่งพาการฉีดด้วยการออกแบบ API สาธารณะ

ฉันได้ไตร่ตรองถึงวิธีการสร้างความสมดุลให้กับการออกแบบที่ทดสอบได้โดยใช้การฉีดแบบพึ่งพาและการให้ API สาธารณะคงที่แบบง่าย ขึ้นเขียงของฉันคือ: ผู้คนต้องการทำสิ่งที่ชอบvar server = new Server(){ ... }และไม่ต้องกังวลเกี่ยวกับการสร้างการอ้างอิงจำนวนมากและกราฟของการอ้างอิงที่ a Server(,,,,,,)อาจมี ในขณะที่กำลังพัฒนาฉันไม่ต้องกังวลมากเกินไปเพราะฉันใช้กรอบ IoC / DI เพื่อจัดการทุกอย่าง (ฉันไม่ได้ใช้แง่มุมการจัดการวงจรชีวิตของคอนเทนเนอร์ใด ๆ ซึ่งจะทำให้สิ่งต่าง ๆ ยุ่งยากมากขึ้น)

ตอนนี้การพึ่งพาไม่น่าจะนำมาใช้ใหม่ การแยกชิ้นส่วนในกรณีนี้เกือบหมดจดสำหรับการทดสอบ (และการออกแบบที่เหมาะสม!) แทนที่จะสร้างตะเข็บเพื่อขยาย ฯลฯ คนจะ 99.999% ของเวลาที่ต้องการใช้การกำหนดค่าเริ่มต้น ดังนั้น. ฉันสามารถ hardcode การอ้างอิง ไม่ต้องการทำอย่างนั้นเราแพ้การทดสอบของเรา! ฉันสามารถสร้างคอนสตรัคเตอร์เริ่มต้นพร้อมการอ้างอิงแบบฮาร์ดโค้ดและตัวอ้างอิงที่ขึ้นต่อกัน นั่นคือ ... ยุ่งและมีแนวโน้มที่จะสับสน แต่ทำงานได้ ฉันสามารถสร้างการพึ่งพาที่ได้รับภายในตัวสร้างและทำให้หน่วยของฉันทดสอบการชุมนุมเพื่อน (สมมติว่า C #) ซึ่งเป็นที่สาธารณะ API สาธารณะ แต่ทิ้งกับดักซ่อนน่ารังเกียจที่ซุ่มซ่อนสำหรับการบำรุงรักษา การมีคอนสตรัคเตอร์สองตัวที่เชื่อมต่อโดยนัยมากกว่าการออกแบบที่ไม่ดีโดยทั่วไปในหนังสือของฉัน

ในขณะนั้นเป็นสิ่งที่ชั่วร้ายที่สุดที่ฉันสามารถนึกได้ ความเห็น? ภูมิปัญญา?

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

ก่อนอื่นให้พิจารณาว่าคุณคาดหวังว่าจะมีคนใช้ API ของคุณอย่างไร - โดยไม่ต้องมีกรอบการทำงาน

• คุณสร้างอินสแตนซ์ของเซิร์ฟเวอร์ได้อย่างไร
• คุณขยายเซิร์ฟเวอร์อย่างไร
• คุณต้องการเปิดเผยอะไรใน API ภายนอก
• คุณต้องการซ่อนอะไรใน API ภายนอก

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

public Server() 
    : this(new HttpListener(80), new HttpResponder())
{}

public Server(Listener listener, Responder responder)
{
    // ...
}

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

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

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

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

ใน Java ในกรณีเช่นนี้เป็นปกติที่จะมีการกำหนดค่า "เริ่มต้น" ที่สร้างโดยโรงงานเก็บเป็นอิสระจากเซิร์ฟเวอร์ที่มีพฤติกรรม "ถูกต้อง" ตามจริง ดังนั้นผู้ใช้ของคุณเขียน:

var server = DefaultServer.create();

ในขณะที่คอนServerสตรัคของยังคงยอมรับการอ้างอิงทั้งหมดและสามารถใช้สำหรับการปรับแต่งลึก

วิธีการเกี่ยวกับการจัดคลาสย่อยซึ่งมี "public api"

class StandardServer : Server
{
    public StandardServer():
        this( depends1, depends2, depends3)
    {
    }
}

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

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

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

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

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

ฉันขอแนะนำให้ใช้InjectableFactory / InjectableInstanceรูปแบบ InjectableInstanceเป็นอาคารเรียนง่ายนำมาใช้ใหม่ซึ่งเป็นผู้ถือคุ้มค่าแน่นอน อินเทอร์เฟซคอมโพเนนต์ประกอบด้วยการอ้างอิงไปยังตัวยึดค่านี้ซึ่งเริ่มต้นด้วยการใช้งานเริ่มต้น อินเทอร์เฟซจะให้วิธีการแบบซิงเกิลget ()ซึ่งมอบหมายให้ผู้ถือค่า ไคลเอ็นต์ส่วนประกอบจะเรียกใช้วิธีการget ()แทนวิธีใหม่เพื่อรับอินสแตนซ์ของการนำไปใช้เพื่อหลีกเลี่ยงการพึ่งพาโดยตรง ในช่วงเวลาทดสอบเราสามารถเลือกแทนที่การใช้งานเริ่มต้นด้วยการจำลอง ฉันจะใช้TimeProviderหนึ่งตัวอย่างคลาสที่เป็นนามธรรมของDate ()เพื่อให้สามารถทดสอบหน่วยในการฉีดและจำลองเพื่อจำลองช่วงเวลาที่แตกต่างกัน ขอโทษฉันจะใช้จาวาที่นี่เพราะฉันคุ้นเคยกับจาวามากขึ้น C # ควรคล้ายกัน

public interface TimeProvider {
  // A mutable value holder with default implementation
  InjectableInstance<TimeProvider> instance = InjectableInstance.of(Impl.class);  
  static TimeProvider get() { return instance.get(); }  // Singleton method.

  class Impl implements TimeProvider {        // Default implementation                                    
    @Override public Date getDate() { return new Date(); }
    @Override public long getTimeMillis() { return System.currentTimeMillis(); }
  }

  class Mock implements TimeProvider {   // Mock implemention
    @Setter @Getter long timeMillis = System.currentTimeMillis();
    @Override public Date getDate() { return new Date(timeMillis); }
    public void add(long offset) { timeMillis += offset; }
  }

  Date getDate();
  long getTimeMillis();
}

// The client of TimeProvider
Order order = new Order().setCreationDate(TimeProvider.get().getDate()));

// In the unit testing
TimeProvider.Mock timeMock = new TimeProvider.Mock();
TimeProvider.instance.setInstance(timeMock);  // Inject mock implementation

InjectableInstance นั้นใช้งานง่ายมากฉันมีการใช้งานอ้างอิงใน java สำหรับรายละเอียดโปรดอ้างอิงโพสต์บล็อกของฉันอ้างอิงทางอ้อมกับโรงงานฉีด