डैगर कस्टम स्कॉप्स, कैसे करें?

Question

डैगर के साथ कस्टम स्कोप कैसे बनाएं?

क्या दिशानिर्देश हैं? मुझे उन्हें नहीं मिला।

मैं एक वैडिन एप्लिकेशन विकसित कर रहा हूं और एक कस्टम स्कोप की आवश्यकता होगी। UiScoped की तरह कुछ।

सादर

Answer 1

डैगर तंत्र Guice करता है कि इसी प्रकार की का उपयोग कर गुंजाइश नहीं करता है। विशेष रूप से, डैगर दृश्यों के पीछे विभिन्न स्कोपिंग एनोटेशन, एक इंजेक्टर, और विभिन्न उदाहरण कैश के साथ गुइस करता है, जिस तरह से गुंजाइश को पारदर्शी रूप से संभाल नहीं करता है। इसके बजाय, यह दो सिद्धांतों का उपयोग करता है। सबसे पहले, @ सिंगलेटन का अर्थ है "प्रति ग्राफ एक" (जेएसआर-330 की सख्त व्याख्या) और दूसरी बात यह है कि ग्राफ को पदानुक्रम में जोड़ा जा सकता है।

डैगर श्रेणीबद्ध रूप से जुड़े आलेखों के इस पेड़ का उपयोग करता है, जहां आप अधिक मॉड्यूल जोड़कर और प्लस() विधि के माध्यम से इसे विस्तारित करते हुए एक ग्राफ बनाते हैं, जो "स्कोप्ड" ग्राफ बनाने के लिए एक छोटा जीवनकाल हो सकता है। यह चावल में बाल इंजेक्टरों के समान है। यहां एक महत्वपूर्ण सिद्धांत यह है कि विस्तारित ग्राफ में उदाहरण मूल ग्राफ में उदाहरण देख सकते हैं, लेकिन विपरीत नहीं। इसलिए कम जीवनकाल की सांद्रिक प्रकृति दृश्यता में प्रतिबिंबित होती है - एक छोटी-जीवित वस्तु एक लंबे समय तक जीवित वस्तु (निर्भर-निर्भर) को देख सकती है, लेकिन विपरीत नहीं। तो एक ऑब्जेक्ट जो अनुरोध के जीवन के लिए रहता है वह एक वस्तु देख सकता है जो किसी एप्लिकेशन के जीवन के लिए रहता है, लेकिन विपरीत नहीं।

यह इस तंत्र के माध्यम से है कि किसी को कैश किए गए उदाहरणों को और अधिक संकुचित करने की उम्मीद है।

यदि कोई मॉड्यूल के साथ ग्राफ को कॉन्फ़िगर करता है, और वहां एक सिंगलटन होता है तो इसमें सभी निर्भर वस्तुओं को प्रदान किए गए ग्राफ में एक उदाहरण कैश किया जाएगा। यदि कोई प्लस() विधि के माध्यम से उस ग्राफ के लिए एक एक्सटेंशन बनाता है, तो इसे अन्य मॉड्यूल के साथ कॉन्फ़िगर करना जिसमें @ सिंगलेटन एनोटेटेड बाइंडिंग शामिल हैं, तो ये अन्य मॉड्यूल एक-प्रति-ग्राफ होंगे ... लेकिन कम-से-कम एक उदाहरण- ऑब्जेक्टग्राफ उदाहरण रहते थे।

उदाहरण के लिए, चलो एक सर्वर है कि अनुरोध, जहां हम कुछ वस्तुओं जो ऐप के जीवन के लिए रहते हैं चाहते हैं का जवाब अनुकरण, और कुछ वस्तुओं जो केवल एक अनुरोध के छोटे-जीवन के लिए रहते हैं:

@Module() 
public class MyAppModule { 
    @Provides ConnectionDictonary connectionDictionary() { 
    return new ConnectionDictonary(System.getProperty("some.property")); 
    } 

    /** Stateless mockable utilities for this app */ 
    @Provides Util util() { new Util(); } 

    @Provides @Singleton DataStore store() { 
    return new DataStore(); 
    } 

    @Provides @Singleton ConnectionPool pool(DataStore store, ConnectionDictionary dict) { 
    try { 
     return DataStore.connectionPool(dict, System.getProperty("pool.size")); 
    } catch (Exception e) { 
     // bad bad bad 
     throw new RuntimeException("Could not connect to datastore.", e); 
    } 
    } 

} 

// This module "adds to" MyAppModule by adding additional graph elements in 
// an extended graph. 
@Module(injects=MyRequestEndpoint.class, addsTo = MyAppModule.class) 
public class MyRequestModule { 
    private Request req; 
    public MyRequestModule(Request req) { this.req = req; } 

    @Provides @Singleton RequestObject request() { return req; } 

    @Provides @Singleton User user(ConnectionPool pool, Request req, Util util) { 
    try { 
     Connection conn = pool.obtain(); 
     // getUser cannot throw null; 
     return util.getUser(conn, req.get("user.id"), Crypto.hash(req.get("pass"))); 
    } catch (UserNotFoundException e) { 
     return User.UNKNOWN; 
    } catch (Exception e) { 
     throw new RuntimeException("Could not obtain a user.", e); 
    } finally { 
     // TODO: try-with-resources in Java7 
     pool.release(); 
    } 
    } 

} 

public class MyRequestEndpoint { 
    @Inject ConnectionPool pool; 
    @Inject Request req; 

    public Output performService() { 
    try { 
     Connection conn = pool.obtain(); 
     // ... does stuff with request 
    } finally { 
     conn.release(); 
    } 
    } 
} 

public class MyApp {  
    public void main(String ... args) { 
    graph = ObjectGraph.create(MyAppModule.class); 
    new ServiceListener(graph).start(); 
    } 
} 

public ServiceListener { 
    private final ObjectGraph appGraph; 
    public ServiceListener(ObjectGraph appGraph) { 
    this.appGraph = appGraph; 
    } 

    //... infrastructure for listening and building request/response objects, etc. 

    public void serveRequest(Request req, Response res) { 
    // Take the application-scoped graph and create another graph we will 
    // use in this request and throw away. 
    ObjectGraph requestGraph = MyApp.graph().plus(new MyRequestModule(req)); 
    Output output = requestGraph.get(MyRequestEndpoint.class).performService(); 
    Util.populateResult(output, result); 
    result.flush(); 
    } 
} 

इस उदाहरण में, प्रत्येक MyRequestEndpoint को कनेक्शनपूल का साझा उदाहरण मिलेगा, लेकिन किसी भी दो अनुरोधों में एक एंडपॉइंट दो अलग-अलग RequestObjects प्राप्त करेगा।

यह कुछ हद तक मूर्ख उदाहरण है जो मेरे सिर के शीर्ष पर जे 2 ईई पैटर्न पर बनाया गया है। इस छोटे से आप इस तरह से संरचना नहीं करेंगे, और आपको उचित सर्वर मॉडल के लिए मजबूत मचान की आवश्यकता होगी। दरअसल, डैगर प्रोजेक्ट ऐसी चीज करेगा (हालांकि मैं इंजेक्शन सेवा ऑब्जेक्ट्स और एक डिस्पैच सर्वलेट या फ़िल्टर का उपयोग करके सम्मानपूर्वक अनुशंसा करता हूं)।

लेकिन यह उम्मीद है कि एक परिचित मॉडल

कुंजी एनोटेशन में नहीं है में एक संकरा गुंजाइश दिखाता है, लेकिन रेखांकन के जीवन में। आप लंबे समय तक रहने वाले ग्राफ के "बच्चे" या "एक्सटेंशन" के रूप में एक छोटा-सा ग्राफ बनाते हैं। इन आलेखों में याद किए गए ऑब्जेक्ट्स में ग्राफ-प्रबंधन ऑब्जेक्ट्स का जीवनकाल (या स्कोप) होता है।