วิธีการแบบค่อยเป็นค่อยไปในการฉีดพึ่งพา

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

วิธีการหนึ่งที่ฉันกำลังสร้างคือการย้ายการเรียก "ใหม่" ทั้งหมดเป็นวิธีการของตนเองเช่น:

public MyObject createMyObject(args) {
  return new MyObject(args);
}

จากนั้นในการทดสอบหน่วยของฉันฉันสามารถคลาสย่อยนี้และแทนที่ฟังก์ชันสร้างดังนั้นพวกเขาจึงสร้างวัตถุปลอมแทน

นี่เป็นวิธีที่ดีหรือไม่? มีข้อเสียหรือไม่?

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

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

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

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

การทำงานพื้นฐานของการอ่านในเรื่องนี้คือการทำงานอย่างมีประสิทธิภาพกับรหัสมรดก มันอธิบายถึงเคล็ดลับที่คุณแสดงด้านบนและอีกมากมายและอีกมากมายโดยใช้หลายภาษา

Guice-folks แนะนำให้ใช้

@Inject
public void setX(.... X x) {
   this.x = x;
}

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

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

ดังนั้นคลาสที่ทดสอบได้ของหน่วยใหม่ของฉันจะมีตัวสร้าง 2 ตัว:

public MyClass() { 
  this(new Client1(), new Client2()); 
}

public MyClass(Client1 client1, Client2 client2) { 
  this.client1 = client1; 
  this.client2 = client2; 
}

คุณอาจต้องการพิจารณาสำนวน "getter สร้าง" จนกว่าคุณจะสามารถใช้การพึ่งพาการฉีด

ตัวอย่างเช่น,

public class Example {
  private MyObject myObject=null;

  public MyObject getMyObject() {
    if (myObject==null) {
      myObject=new MyObject();
    } 
    return myObject;
  }

  public void setMyObject(MyObject myObject) {
    this.myObject=myObject;
  }

  private void myMethod() {
    if (getMyObject().doSomething()) {
      // Instance automatically created
    }
  }
}

สิ่งนี้จะอนุญาตให้คุณ refactor ภายในเพื่อให้คุณสามารถอ้างอิง myObject ของคุณผ่านทะเยอทะยาน newคุณไม่ต้องโทร ในอนาคตเมื่อไคลเอนต์ทั้งหมดได้รับการกำหนดค่าให้อนุญาตการฉีดพึ่งพาแล้วสิ่งที่คุณต้องทำคือลบรหัสการสร้างในที่เดียว - ทะเยอทะยาน ตัวตั้งค่าจะอนุญาตให้คุณฉีดวัตถุจำลองตามต้องการ

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

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