Java Academy · บทเรียน

การฉีดผ่านคอนสตรักเตอร์และดีเพนเดนซีแบบวนรอบ

เลือกใช้การฉีดผ่านคอนสตรักเตอร์เพื่อให้ทดสอบได้ง่าย ตรวจจับดีเพนเดนซีแบบวนรอบ และแก้ไขด้วย @Lazy

บทเรียน 4 จาก 413 ขั้นตอน

การฉีดผ่านคอนสตรักเตอร์และดีเพนเดนซีแบบวนรอบ เป็นบทเรียน Java Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 4 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Java Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Java Academy มีบทเรียนทั้งหมด 4 บทเรียน

การฉีดสามรูปแบบ

Spring รองรับการฉีดผ่านคอนสตรัคเตอร์ (แนะนำ), การฉีดผ่านฟิลด์ (ใส่ @Autowired บนฟิลด์) และการฉีดผ่านเซตเตอร์ ควรเลือกการฉีดผ่านคอนสตรัคเตอร์เนื่องจากช่วยให้ทดสอบได้ง่ายและทำให้ค่าไม่เปลี่ยนแปลง

การฉีดผ่านคอนสตรัคเตอร์

ประกาศการพึ่งพาเป็นพารามิเตอร์ของคอนสตรัคเตอร์ Spring จะฉีดการพึ่งพาเหล่านั้นให้โดยอัตโนมัติ หากมีคอนสตรัคเตอร์เพียงตัวเดียว ก็ไม่จำเป็นต้องใช้ @Autowired (Spring Boot 2.1 ขึ้นไป)

@Service
public class OrderService {
    private final OrderRepository repo;
    private final EmailService email;
    // @Autowired is optional when there is only one constructor
    public OrderService(OrderRepository repo, EmailService email) {
        this.repo  = repo;
        this.email = email;
    }
}

เหตุผลที่ควรเลือกการฉีดผ่านคอนสตรัคเตอร์

การฉีดผ่านคอนสตรัคเตอร์มีข้อดีดังนี้: (1) การพึ่งพาเป็นค่าคงที่ จึงไม่เปลี่ยนแปลง (2) คลาสจะเริ่มต้นอย่างสมบูรณ์เสมอ และ (3) การทดสอบหน่วยไม่ต้องพึ่งพา Spring เพียงเรียก new OrderService(mockRepo, mockEmail) ก็เพียงพอ

// Unit test — no Spring context needed:
OrderRepository mockRepo  = mock(OrderRepository.class);
EmailService    mockEmail = mock(EmailService.class);
OrderService    service   = new OrderService(mockRepo, mockEmail);
// Test service logic directly

การฉีดผ่านฟิลด์ (ควรหลีกเลี่ยง)

การฉีดผ่านฟิลด์ด้วย @Autowired ทำให้โค้ดกระชับ แต่มีปัญหาหลายประการ ได้แก่ ฟิลด์ไม่สามารถเป็น final ได้ บีนจะยังเริ่มต้นไม่สมบูรณ์หลังการสร้าง และการทดสอบหน่วยต้องใช้ Spring หรือตัวช่วยการสะท้อนของ Mockito

// Avoid in production code:
@Service
public class UserService {
    @Autowired  // hidden dependency
    private UserRepository repo; // cannot be final
}

การฉีดผ่านเซตเตอร์สำหรับการพึ่งพาที่เป็นทางเลือก

ใช้การฉีดผ่านเซตเตอร์สำหรับการพึ่งพาที่เป็นทางเลือกและมีค่าเริ่มต้นที่เหมาะสม โดยกำกับเซตเตอร์ด้วย @Autowired(required = false)

@Service
public class NotificationService {
    private SmsSender smsSender; // optional
    @Autowired(required = false)
    public void setSmsSender(SmsSender s) { this.smsSender = s; }
}

การพึ่งพาแบบวนรอบคืออะไร

การพึ่งพาแบบวนรอบเกิดขึ้นเมื่อ A ต้องใช้ B และ B ต้องใช้ A (โดยตรงหรือผ่านการพึ่งพาต่อเนื่อง) Spring จะตรวจพบปัญหานี้เมื่อเริ่มต้นระบบและโยน BeanCurrentlyInCreationException

// CIRCULAR:
@Service class A { A(B b) {} }
@Service class B { B(A a) {} }
// Spring throws: BeanCurrentlyInCreationException: Is there an unresolvable circular reference?

แก้การพึ่งพาวนรอบ: ปรับโครงสร้างเป็นบริการที่สาม

วิธีแก้ที่สะอาดที่สุดคือแยกตรรกะที่ใช้ร่วมกันออกมาเป็นบริการที่สาม ซึ่งทั้ง A และ B ไม่ได้พึ่งพาแบบวนรอบ

// Before: A <-> B
// After: A -> C, B -> C (no cycle)
@Service class SharedLogic { ... }
@Service class A { A(SharedLogic s) {} }
@Service class B { B(SharedLogic s) {} }

แก้การพึ่งพาวนรอบ: @Lazy

ใส่คำอธิบายประกอบ @Lazy ที่จุดฉีดจุดใดจุดหนึ่ง Spring จะสร้างพร็อกซีสำหรับ B ทันที แต่จะสร้างอินสแตนซ์ของ B จริงเมื่อ A เรียกใช้เมธอดของ B เป็นครั้งแรกเท่านั้น

@Service
public class A {
    private final B b;
    public A(@Lazy B b) { this.b = b; } // breaks the cycle
}

แก้การพึ่งพาวนรอบ: ค้นหาผ่าน ApplicationContext

ฉีด ApplicationContext เข้าไปในบีนตัวหนึ่ง แล้วค้นหาบีนอีกตัวแบบเลื่อนเวลาผ่าน context.getBean() แต่วิธีนี้ทำให้การทดสอบและความชัดเจนของโค้ดลดลง

@Service
public class A implements ApplicationContextAware {
    private ApplicationContext ctx;
    public void setApplicationContext(ApplicationContext c) { this.ctx = c; }
    public void doWork() { ctx.getBean(B.class).help(); }
}

ใช้การฉีดผ่านเซตเตอร์เพื่อแก้การพึ่งพาวนรอบ

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

@Service
public class A {
    private B b;
    @Autowired public void setB(B b) { this.b = b; } // Spring sets after construction
}

spring.main.allow-circular-references (Spring Boot 2.6 ขึ้นไป)

Spring Boot 2.6 ขึ้นไปไม่อนุญาตให้มีการพึ่งพาแบบวนรอบเป็นค่าเริ่มต้น ควรเปิดใช้งานอย่างชัดเจนเฉพาะชั่วคราวระหว่างปรับโครงสร้างโค้ดเท่านั้น: spring.main.allow-circular-references=true

# application.properties (temporary workaround only):
spring.main.allow-circular-references=true

ตรวจสอบความเข้าใจอย่างรวดเร็ว

เหตุใดจึงควรเลือกการฉีดผ่านคอนสตรัคเตอร์แทนการฉีดผ่านฟิลด์

ตอบคำถามในบทเรียนแบบโต้ตอบ

ทบทวน

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

เริ่มต้นได้ฟรี

เรียนรู้ Java ด้วย AI tutor — ฟรี

เขียนและเรียกใช้โค้ดจริงในเบราว์เซอร์ของคุณ รับความช่วยเหลือทันทีจาก AI tutor 24/7 และเรียนรู้ต่อจากที่คุณหยุดบนเว็บหรือในแอป

คอร์ส: 104
บทเรียน: 374

เริ่มเรียนฟรี ดูหลักสูตรเต็ม

คำถามที่พบบ่อย

บทเรียน “การฉีดผ่านคอนสตรักเตอร์และดีเพนเดนซีแบบวนรอบ” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “การฉีดผ่านคอนสตรักเตอร์และดีเพนเดนซีแบบวนรอบ” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Java Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Java Academy มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “การฉีดผ่านคอนสตรักเตอร์และดีเพนเดนซีแบบวนรอบ”

เลือกใช้การฉีดผ่านคอนสตรักเตอร์เพื่อให้ทดสอบได้ง่าย ตรวจจับดีเพนเดนซีแบบวนรอบ และแก้ไขด้วย @Lazy คุณปฏิบัติ Java Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Java Academy หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน Java Academy บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 4 จากทั้งหมด 4 บทเรียน

บทเรียน “การฉีดผ่านคอนสตรักเตอร์และดีเพนเดนซีแบบวนรอบ” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน Java Academy นี้ได้ไหม

ได้ บทเรียน Java Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

การกำหนดค่าอัตโนมัติและตัวเริ่มต้น Spring Boot
คุณสมบัติแอปพลิเคชันและโปรไฟล์
การเชื่อมโยง Bean: @Component, @Service, @Repository
การฉีดผ่านคอนสตรักเตอร์และดีเพนเดนซีแบบวนรอบ

← กลับไปที่ Java Academy