वसंत: हम इंटरफ़ेस को स्वचालित क्यों करते हैं, न कि कार्यान्वित कक्षा?

Question

उदाहरण

interface IA 
{ 
    public void someFunction(); 
} 

@Resource(name="b") 
class B implements IA 
{ 
    public void someFunction() 
    { 
    //busy code block 
    } 
    public void someBfunc() 
    { 
    //doing b things 
    } 
} 

@Resource(name="c") 
class C implements IA 
{ 
    public void someFunction() 
    { 
    //busy code block 
    } 
    public void someCfunc() 
    { 
    //doing C things 
    } 
} 

class MyRunner 
{ 

    @Autowire 
    @Qualifier("b") 
    IA worker; 

    worker.someFunction(); 
} 

किसी ने मुझे इस व्याख्या कर सकते हैं।

• वसंत कैसे पता चलता है कि कौन से बहुरूप प्रकार का उपयोग करना है।
• क्या मुझे @Qualifier या @Resource की आवश्यकता है?
• हम इंटरफ़ेस को स्वचालित क्यों करते हैं, न कि कार्यान्वित कक्षा?

Answer 1

वसंत कैसे पता चलता है कि किस बहुलक प्रकार का उपयोग करना है।

जब तक वहाँ केवल इंटरफेस की एक एकल कार्यान्वयन है और है कि कार्यान्वयन वसंत के घटक स्कैन सक्षम, स्प्रिंग फ्रेमवर्क (इंटरफेस, कार्यान्वयन) जोड़ी पता कर सकते हैं के साथ @Component साथ टिप्पणी की जाती है के रूप में। यदि घटक स्कैन सक्षम नहीं है, तो आपको बीन को अपने एप्लिकेशन-config.xml (या समतुल्य वसंत कॉन्फ़िगरेशन फ़ाइल) में स्पष्ट रूप से परिभाषित करना होगा।

क्या मुझे @Qualifier या @Resource की आवश्यकता है?

एक बार जब आप एक से अधिक कार्यान्वयन है, तो आप उनमें से और स्वत: तारों के दौरान प्रत्येक अर्हता प्राप्त करने की जरूरत है, तो आप सही कार्यान्वयन सुई, @Autowired एनोटेशन के साथ @Qualifier एनोटेशन का उपयोग करने की आवश्यकता होगी। यदि आप @Resource (J2EE semantics) का उपयोग कर रहे हैं, तो आपको इस एनोटेशन के name विशेषता का उपयोग करके बीन नाम निर्दिष्ट करना चाहिए।

हम इंटरफ़ेस को स्वचालित क्यों करते हैं, न कि कार्यान्वित कक्षा?

सबसे पहले, सामान्य रूप से इंटरफेस को कोड करना हमेशा एक अच्छा अभ्यास है। दूसरा, वसंत के मामले में, आप रनटाइम पर किसी भी कार्यान्वयन को इंजेक्ट कर सकते हैं। एक सामान्य उपयोग केस परीक्षण चरण के दौरान नकली कार्यान्वयन इंजेक्षन है।

interface IA 
{ 
    public void someFunction(); 
} 


class B implements IA 
{ 
    public void someFunction() 
    { 
    //busy code block 
    } 
    public void someBfunc() 
    { 
    //doing b things 
    } 
} 


class C implements IA 
{ 
    public void someFunction() 
    { 
    //busy code block 
    } 
    public void someCfunc() 
    { 
    //doing C things 
    } 
} 

class MyRunner 
{ 
    @Autowire 
    @Qualifier("b") 
    IA worker; 

    .... 
    worker.someFunction(); 
} 

आपका सेम विन्यास इस तरह दिखना चाहिए:

<bean id="b" class="B" /> 
<bean id="c" class="C" /> 
<bean id="runner" class="MyRunner" /> 

वैकल्पिक रूप से, अगर आप पैकेज जहां इन मौजूद हैं पर घटक स्कैन सक्षम है, तो आप प्रत्येक वर्ग @Component साथ अर्हता प्राप्त करना चाहिए इस प्रकार है:

interface IA 
{ 
    public void someFunction(); 
} 

@Component(value="b") 
class B implements IA 
{ 
    public void someFunction() 
    { 
    //busy code block 
    } 
    public void someBfunc() 
    { 
    //doing b things 
    } 
} 


@Component(value="c") 
class C implements IA 
{ 
    public void someFunction() 
    { 
    //busy code block 
    } 
    public void someCfunc() 
    { 
    //doing C things 
    } 
} 

@Component  
class MyRunner 
{ 
    @Autowire 
    @Qualifier("b") 
    IA worker; 

    .... 
    worker.someFunction(); 
} 

workerMyRunnerB के उदाहरण के साथ इंजेक्शन दिया जाएगा।

Answer 2

इसके अलावा यह Cglib2AopProxy Unable to proxy method जैसे लॉग में कुछ चेतावनी का कारण बन सकता है। और इसके लिए कई अन्य कारणों का वर्णन यहां किया गया है Why always have single implementaion interfaces in service and dao layers?