परिपत्र निर्भरताओं के साथ गुइस का उपयोग

Question

इस सरल उदाहरण पर विचार करें।

Class A { 
    B b; 
    A() { 
     this.b = new B(this); 
    } 
} 

इस उदाहरण उदाहरण एक में उदाहरण बी के बारे में जानता है, और उदाहरण बी उदाहरण ए के बारे में जानता

मेरा प्रश्न है: कैसे Guice, यानी साथ उदाहरण के एक दृष्टांत को Guice देखभाल करने के लिए कैसे इस जटिल सर्कल निर्भरताओं के?

Answer 1

अपने पहले प्रश्न का उत्तर देने के लिए "तत्काल कैसे करें Guice के साथ "उदाहरण एक: आप बस निर्माता को @Inject जोड़ सकते हैं:

class A { 
    private final B b; 

    @Inject 
    A() { 
     this.b = new B(this); 
    } 
} 

यह काम करता है क्योंकि A बनाने के लिए एपीआई एक सर्कुलर निर्भरता नहीं है। गुइस A कन्स्ट्रक्टर का उपयोग करेगा जब भी इसे A ऑब्जेक्ट बनाने या इंजेक्ट करने की आवश्यकता होगी।

यदि आपका प्रश्न यह है कि ऑब्जेक्ट बनाने के लिए एआईपी बनाने के लिए गुइस का उपयोग कैसे किया जाए, जहां ऑब्जेक्ट बनाने के लिए एपीआई में गोलाकार निर्भरता है, तो this blog post by Misko Hevery (जैसा कि यूरी के उत्तर में उल्लिखित है) देखें।

Answer 2

उत्तर यह है कि आपको अपने कोड में परिपत्र निर्भरता पर निर्भरता इंजेक्शन ढांचे का उपयोग नहीं करना चाहिए।

तो, आपको पहले कोड को दोबारा प्रतिक्रिया देना होगा। जहां तक ​​मुझे पता है, कड़े युग्मित वर्गों के लिए दो समाधान हैं: या तो दो वर्गों को एक में मिलाएं या नई कक्षा शुरू करें और इसमें सामान्य तर्क को स्थानांतरित करें (विस्तार से here देखें)

Answer 3

आपका उदाहरण बिल्कुल कोई मुद्दा नहीं है, क्योंकि आप सीधे बी का निर्माण कर रहे हैं। लेकिन यदि आप गुइस द्वारा ए और बी दोनों बनना चाहते हैं, तो एक या दोनों एक इंटरफ़ेस होना चाहिए। आप कर सकते हैं:

public interface A { /* skipping methods */ } 
public interface B { /* skipping methods */ } 

public class AImpl implements A { 
    private final B b; 

    @Inject 
    public AImpl(B b) { 
     this.b = b; 
    } 
    // ... 
} 

public class BImpl implements B { 
    private final A a; 

    @Inject 
    public BImpl(A a) { 
     this.a = a; 
    } 
    // ... 
} 

यहां तक ​​कि अगर AImpl और BImpl एकमात्र, Guice इस इंजेक्शन (एक प्रॉक्सी के माध्यम से) संभाल कर सकते हैं के रूप में scoped रहे हैं। यह किसी भी दर पर इस तरह के एक साधारण मामले में काम करता है ... मुझे लगता है कि वहां अधिक जटिल परिपत्र निर्भरताएं हो सकती हैं जो इसे संभाल नहीं सकतीं। वैसे भी, सर्कुलर निर्भरताओं को समाप्त करना निश्चित रूप से बेहतर होगा।

Answer 4

मुझे लगता है कि NamshubWriter का प्रस्ताव बहुत मूर्ख नहीं है। मुझे लगता है कि गुइस में, एक निर्माता को बिल्कुल एक काम करना चाहिए: फ़ील्ड में पैरामीटर असाइन करें। अगर आपको कुछ और करने की ज़रूरत है, तो उसे कारखाने या प्रदाता में डाल दें।

इस मामले में, हम ए के लिए प्रदाता चाहते हैं। प्रदाता सीधे नए बी() को कॉल कर सकता है, लेकिन फिर हम सीधे ए से बी को जोड़ देंगे, जिसे हमने पहले स्थान से बचने की कोशिश की थी। इसलिए हम एक फैक्ट्री पर बी के निर्माण पर अप्रत्यक्ष हैं, जो कि guiceInjectedject के माध्यम से हमारे लिए गुजर प्रदान कर सकता है। यह कोड ठीक चलाता है और संकलित करता है, और पूरी तरह से ए और बी

एक यथार्थवादी परिदृश्य में, आपको पृथक्करण का लाभ उठाने के लिए इंटरफेस के पीछे ए और बी को छिपाने की आवश्यकता होगी।

import com.google.inject.AbstractModule; 
import com.google.inject.Guice; 
import com.google.inject.Inject; 
import com.google.inject.Provider; 
import com.google.inject.assistedinject.Assisted; 
import com.google.inject.assistedinject.FactoryProvider; 

public class Try { 
    public static void main(String[] args) { 
     System.out.println(
       Guice.createInjector(new MyModule()).getInstance(A.class) 
     ); 
    } 
} 

class MyModule extends AbstractModule { 
    public void configure() { 
     bind(A.class).toProvider(AProvider.class); 
     bind(IBFactory.class).toProvider(
       FactoryProvider.newFactory(IBFactory.class, B.class)); 
    } 
} 

class A { 
    B b; 

    public void setB(B b) { 
     this.b = b;  
    } 
} 

class B { 
    A a; 

    @Inject 
    B(@Assisted A a) { 
     this.a = a; 
    } 
} 

class AProvider implements Provider<A> { 

    private final IBFactory bFactory; 

    @Inject 
    AProvider(IBFactory bFactory) { 
     this.bFactory = bFactory; 
    } 

    public A get() { 
     A a = new A(); 
     a.setB(bFactory.create(a)); 
     return a; 
    } 
} 

interface IBFactory { 
    public B create(A a); 
} 

I made an extended version of the circular dependency injection in Guice where A and B are hidden behind interfaces.