स्प्रिंग इंटरफ़ेस इंजेक्शन उदाहरण

Question

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

तीन प्रकार के इंजेक्शन हैं: कन्स्ट्रक्टर, सेटर और इंटरफेस। वसंत नवीनतम रूप से सीधे समर्थन नहीं करता है (जैसा कि मैंने लोगों को यह कहते हुए देखा है)। तो यह वास्तव में कैसे किया जाता है?

धन्यवाद, इंटरफ़ेस इंजेक्शन के साथ

Answer 1

करने के लिए Variants of DI in spring

डि दो प्रमुख वेरिएंट, निर्माता आधारित निर्भरता इंजेक्शन और सेटर आधारित निर्भरता इंजेक्शन में मौजूद अनुसार।

इसके अलावा Interface injection is not implemented in Spring देख स्पष्ट रूप से यह कहा गया।

तो DI के केवल दो प्रकार हैं। इसलिए यदि दस्तावेज़ इंटरफ़ेस इंजेक्शन के बारे में कुछ भी नहीं कहता है, तो यह स्पष्ट है कि यह वहां नहीं है। जो लोग मानते हैं कि इंटरफेस इंजेक्शन प्रदाता द्वारा किया जाता है इंटरफ़ेस में आईएनजी सेटर विधि मुझे उत्तर दें:

1. क्यों वसंत रेफ डॉक इंटरफ़ेस इंजेक्शन का उल्लेख छोड़ दिया?
2. सेटर विधि को सेटर इंजेक्शन के रूप में नहीं माना जाता है, तो इंटरफ़ेस इंजेक्शन क्यों नहीं लगा सकता है। इसके लिए विशेष शब्द क्यों बनाएं जब इंटरफ़ेस का परिचय कुछ भी प्रभावित नहीं करता है, मेरा मतलब है कि यह अभी भी उसी तरह कॉन्फ़िगर किया गया है। अगर वे अलग थे तो कॉन्फ़िगरेशन को देखकर इसे कैसे ढूंढ सकता है। क्या यह पारदर्शी नहीं होना चाहिए कि कॉन्फ़िगरेशन में और वास्तव में कॉन्फ़िगर किए गए इंप को नहीं देख रहा है जो कुछ इंटरफ़ेस लागू करता है?
3. बस Instantiation using an instance factory method और Instantiation using an static factory method की तरह, कुछ बीन विशेषताओं को इंटरफ़ेस इंजेक्शन को स्पष्ट करना चाहिए?

   1. Constructor Injection(E.g Pico Container, Spring supports it). 
   2. Setter Injection(E.g Spring supports it). 
   3. Interface Injection(E.g Avalon, Spring does not support it). 
   

   स्प्रिंग केवल निर्माता और सेटर आधारित इंजेक्शन का समर्थन करता है -:

Answer 2

एक अंतरफलक स्पष्ट बिंदु है जहां निर्भरता सेट किया जा सकता परिभाषित करता है:

interface InjectPerson { 
    public void injectHere(Person p); 
} 

class Company implements InjectPerson { 
    Person injectedPerson; 

    public void injectHere(Person p) { 
     this.injectedPerson = p; 
    } 
} 

Answer 3

हाय मैं एक बहुत ही सरल दृष्टिकोण है कि आपका जवाब स्पष्ट कर सकता है के साथ की कोशिश की।

निम्नलिखित कोड है जिसे मैंने दो इंटरफेस और दो बीन कक्षाओं का उपयोग करने पर बनाया है।

नाम नौकरी के साथ पहला इंटरफ़ेस।

public interface Job { 
    public void setmyJob(String myJob); 
    public String getmyJob(); 
} 

और एक वर्ग एक और वर्ग के लिए फिर से MyJob

public class MyJob implements Job { 
    public String myJob; 

    public MyJob() { 
     System.out.println("From MyJob default Constructor and the ID= "+this); 
    } 

    public void setmyJob(String myJob) { 
     this.myJob=myJob; 
    } 

    public String getmyJob() { 
     return myJob; 
    } 
} 

के रूप में नाम के साथ इस इंटरफ़ेस को लागू करने के लिए अगले कदम मैं सेवा

रूप

public interface Service { 
    public void setJob(Job job); 
    public Job getJob(); 
} 

नाम के साथ एक और इंटरफ़ेस बनाई में और उसके बाद इस सेवा इंटरफेस को लागू करें।

public class MyService implements Service { 

    public Job job; 

    public void setJob(Job job) { 
     this.job=job; 
     System.out.println("Hello from Myservice: Job ID="+job); 
    } 

    public Job getJob() { 
     return job; 
    } 
} 

तो मैं मुख्य कार्य के साथ मुख्य वर्ग पर बनाया गया है और इस प्रकार कोड लिखा:

import org.springframework.beans.factory.BeanFactory; 
import org.springframework.context.ApplicationContext; 
import org.springframework.context.support.ClassPathXmlApplicationContext; 
public class MainApplication { 

    public static void main(String...a) { 

     BeanFactory beanfactory=new ClassPathXmlApplicationContext("Beans.xml"); 

     MyService myservice=(MyService)beanfactory.getBean("myservice"); 
     System.out.println("Before print"); 
     System.out.println(myservice.getJob().getmyJob()); 
    } 
} 

मेरी Beans.xml फ़ाइल में मैं के रूप में इस प्रकार है और यह काम किया कोड का उल्लेख किया।

<?xml version="1.0" encoding="UTF-8"?> 
<beans xmlns="http://www.springframework.org/schema/beans" 
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
xsi:schemaLocation="http://www.springframework.org/schema/beans 
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd"> 


    <bean id="myjob" class="MyJob"> 
     <property name="myJob" value="My First String"/> 
    </bean> 

    <bean id="myservice" class="MyService"> 
     <property name="job" ref="myjob"/> 
    </bean> 
</beans> 

मैं भी एक और ऑनलाइन ट्यूटोरियल करने के लिए भेजा है और फिर समाधान इस तरह का हो गया। अगर आपको इस कोड के साथ कोई समस्या है तो कृपया मुझे बताएं। यह मेरे लिए काम कर रहा है।

Answer 4

मैं किसी को अपने प्रश्नों का उत्तर here मैं भी नहीं पता था कि क्या इंटरफ़ेस इंजेक्शन है जब तक मैं "वेब प्रवाह किताब के साथ प्रो वसंत MVC" से इस बयान को पढ़ने के

"ध्यान दें कि इंटरफेस आधारित निर्भरता इंजेक्शन प्रतिसाद नहीं लगता है स्प्रिंग फ्रेमवर्क द्वारा समर्थित नहीं है। यह का अर्थ है कि हमें एक निश्चित इंटरफ़ेस के लिए इंजेक्ट करने के लिए कौन सा ठोस कार्यान्वयन निर्दिष्ट करना होगा।"

Answer 5

निर्भरता इंजेक्शन के 3 प्रकार के होते हैं। ऐसा लगता है कि आप विभिन्न प्रकारों (3) में उलझन में हैं और वसंत का समर्थन करता है (उनमें से 2)।

Answer 6

कृपया इसे इयरफेस इंजेक्शन के लिए नीचे दिए गए उदाहरण की जांच करें।

एक आकार इंटरफ़ेस और 2 ठोस वर्ग हैं जो आकार और आयताकार आकार का आकार बदलते हैं।

इंटरफ़ेस

package di.interfaceinjection; 
public interface Shape { 
    public String shapeName(); 
    public void displayName(); 
} 

2 कार्यान्वित कक्षाएं

package di.interfaceinjection; 

public class Square implements Shape { 

    @Override 
    public String shapeName() { 
     return "Square"; 
    } 

    @Override 
    public void displayName() { 
     System.out.println("Square");  
    } 

} 

package di.interfaceinjection; 

public class Rectangle implements Shape{ 

    @Override 
    public String shapeName() { 
     return "Rectangle"; 
    } 

    @Override 
    public void displayName() { 
     System.out.println("Rectangle");   
    } 

} 

अब, हम एक वर्ग जो आकार सेट की है।

public class ShapeSetter { 

    private Shape shape; 

    public Shape getShape() { 
     return shape; 
    } 

    public void setShape(Shape shape) { 
     this.shape = shape; 
    } 

} 

और अंत विन्यास

<bean id="shape1" class="di.interfaceinjection.ShapeSetter"> 
    <property name="shape" ref="square"></property> 
    </bean> 
    <bean id="shape2" class="di.interfaceinjection.ShapeSetter"> 
    <property name="shape" ref="rectangle"></property> 
    </bean> 
    <bean id="square" class="di.interfaceinjection.Square"></bean> 
    <bean id="rectangle" class="di.interfaceinjection.Rectangle"></bean> 

यहाँ,

हम अलग अलग आकार इंजेक्शन कर रहे हैं।

package di.interfaceinjection; 

import org.springframework.context.ApplicationContext; 
import org.springframework.context.support.ClassPathXmlApplicationContext; 

public class InterfaceInjeection { 

    /** 
    * @param args 
    */ 
    public static void main(String[] args) { 
     ApplicationContext appContext = new ClassPathXmlApplicationContext("intro.xml"); 
     ShapeSetter shape = (ShapeSetter)appContext.getBean("shape2"); 
     shape.getShape().displayName(); 
    } 

} 

Answer 7

मुझे लगता है, कि इंटरफेस इंजेक्शन के आसपास भ्रम missunderstanding क्या शब्द "इंटरफेस इंजेक्शन" वास्तव में मतलब है के कारण होता है। मेरी समझ में, इंटरफ़ेस इंजेक्शन बीन के लिए एक नया इंटरफेस इंजेक्ट करने के लिए एक बीन contener की क्षमता का वर्णन करता है, इससे कोई फर्क नहीं पड़ता कि इस बीन की कक्षा परिभाषा इसे कार्यान्वित नहीं कर रहा है।

यहां प्रस्तुत सभी उदाहरण दिखाते हैं कि कैसे ठोस वर्ग से एक बीन बनाने के लिए, और फिर इसे किसी अन्य बीन में कैसे इंजेक्ट करना है। तथ्य यह है कि सभी मामलों में बीन को एक इंटरफ़ेस के रूप में परिभाषित क्षेत्र में इंजेक्शन दिया जाता है इससे कोई फर्क नहीं पड़ता- सभी परिचालन ठोस उदाहरणों से बने बीन्स के साथ किए जाते हैं।

package creditCards; 

interface PaymentCard { 
    Boolean isDebitAllowed(); 
} 

    <bean id="card" class="creditCards.PaymentCard"> 
     <lookup-method name="isDebitAllowed" bean="boolValue"/> 
    </bean> 

    <bean id="boolValue" class="java.lang.Boolean"> 
     <constructor-arg type="boolean" value="true"/> 
    </bean> 

आप यहाँ देख के रूप में, यह भी संभव है इंटरफ़ेस से बाहर एक सेम बनाने के लिए:

मैं भी एक और आकर्षक उदाहरण प्रदान कर सकते हैं! फिर भी, यह एक इंटरफ़ेस इंजेक्शन नहीं है, क्योंकि आईओसी कंटनर इस बीन के अपने स्वयं के इंस्टेंस को प्रारंभ करता है। दूसरे शब्दों में, card बीन एक प्रारंभिक वस्तु है, इंटरफ़ेस नहीं, जो बनाता है, कि इस प्रश्न का चयनित उत्तर सही है।