web-dev-qa-db-de.com

Beispiel für eine Federschnittstelle

Bisher konnte niemand ein funktionierendes Beispiel für die Schnittstelleninjektion in Spring Framework liefern. Martin Fowlers Artikel ist nichts für Sterbliche, alles andere sind nur Wörter, die auf sehr verwirrende Weise positioniert werden. Ich habe über THIRTY-Artikel gesurft, in denen die Leute entweder sagen "Spring unterstützt nicht direkt die Schnittstelleninjektion" ("und weil ich nicht genau weiß, wie ich nur Setter- und Konstruktorinjektionen beschreibe") oder "Ich werde es in meinem Text besprechen." andere Threads "oder entweder werden unten einige Kommentare dazu kommen, dass es ein falsches Beispiel ist. Ich frage nicht nach einer Erklärung, ich BEGE zum Beispiel.

Es gibt drei Arten der Injektion: Konstruktor, Setter und Interface. Der Frühling unterstützt das Neueste nicht direkt (wie ich beobachtet habe). Wie wird es genau gemacht?

Danke dir,

25
Aubergine

Nach Varianten von DI im Frühling

DI gibt es in zwei Hauptvarianten: Konstruktor-basierte Abhängigkeitseinspritzung und Setter-basierte Abhängigkeitseinspritzung.

Siehe auch Schnittstelleneinspritzung ist nicht in Spring implementiert gibt dies eindeutig an.

Es gibt also nur zwei Varianten von DI. Wenn also die Dokumentation nichts über die Schnittstelleninjektion aussagt, ist klar, dass sie nicht vorhanden ist. Diejenigen, die glauben, dass die Schnittstelleninjektion durch die Bereitstellung einer Setter-Methode in der Schnittstelle erfolgt, antworten mir:

  1. Warum wurde in der Quellenreferenz der Schnittstelle die Schnittstelleneinspritzung erwähnt?
  2. Warum kann die Schnittstelleninjektion nicht über die Settermethode NICHT erfolgen, die als Setterinjektion selbst betrachtet wird? Warum einen speziellen Begriff dafür erstellen, wenn die Einführung der Schnittstelle nichts beeinflusst, meine ich, dass sie immer noch auf dieselbe Weise konfiguriert ist. Wenn sie anders wären, wie kann man es finden, indem man die Konfig sieht. Sollte es nicht transparent sein, dass in config und nicht das impl. Der tatsächlich konfigurierten Klasse eine Schnittstelle implementiert wird?
  3. Genauso wie Instanziierung mit einer Instanz-Factory-Methode und Instantiierung mit einer statischen Factory-Methode , sollten einige Bean-Attribute die Schnittstelleninjektion klären?
10
nanosoft

Beim Interface-Injection definiert ein Interface explizit den Punkt, an dem eine Abhängigkeit eingestellt werden kann

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

class Company implements InjectPerson {
   Person injectedPerson; 

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

Hallo, ich habe es mit einem sehr einfachen Ansatz versucht, der Ihre Antwort verdeutlichen könnte.

folgendes ist der Code, den ich mit zwei Interfaces und zwei Bean-Klassen aufgebaut habe.

erste Schnittstelle mit dem Namen Job.

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

und eine Klasse, um diese Schnittstelle mit dem Namen MyJob zu implementieren

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;
    }
}

Im nächsten Schritt habe ich eine weitere Schnittstelle mit dem Namen Service erstellt

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

und dann wieder eine andere Klasse, um diese Service-Schnittstelle zu implementieren.

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;
    }
}

dann habe ich on main class mit der main-Funktion erstellt und den Code wie folgt geschrieben:

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());
    }
}

in meiner Beans.xml-Datei erwähnte ich den Code wie folgt und er funktionierte.

 <?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>

Ich habe auch auf andere Online-Tutorials verwiesen und diese Lösung gefunden. Bitte lassen Sie mich wissen, wenn Sie Probleme mit diesem Code haben. es funktioniert für mich.

6
Vinay Pandey

Es gibt 3 Arten von Abhängigkeitsinjektionen: -

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).

Feder unterstützt nur Konstruktor- und Setzer-basierte Einspritzung. Sieht aus, als wären Sie in den verschiedenen Typen (3) und in welchen Federhaltern (2) verwirrt.

2
Goyal Vicky

Bitte überprüfen Sie das Beispiel unten für die Iterface-Injektion.

Es gibt eine Formschnittstelle und 2 konkrete Klassen, deren Eindringlinge Quadrat und Rechteck formen.

Die Schnittstelle

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

2 Implementierte Klassen

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");        
    }

}

Nun haben wir eine Klasse, die die Form bestimmt.

public class ShapeSetter {

    private Shape shape;

    public Shape getShape() {
        return shape;
    }

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

}

und schließlich die Konfiguration

<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>

Hier,

wir spritzen verschiedene Formen.

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();
    }

}
1
Sivaranjani D

Ich denke, dass die Verwirrung um die Schnittstelleninjektion durch Missverständnisse verursacht wird, was der Begriff "Schnittstelleninjektion" eigentlich bedeutet. In meinem Verständnis beschreibt Interface-Injection die Fähigkeit eines Bean-Contensers, dem Bean ein neues Interface zu injizieren, unabhängig davon, ob die Klassendefinition dieses Beans es nicht implementiert.

Alle hier vorgestellten Beispiele zeigen, wie Sie eine Bean aus einer konkreten Klasse erstellen und dann in eine andere Bean injizieren. Die Tatsache, dass die Bean in alle Fälle in ein als Interface definiertes Feld injiziert wird, spielt keine Rolle. Alle Operationen werden mit Beans ausgeführt, die aus konkreten Instanzen erstellt wurden. 

Ich kann auch ein anderes eingängiges Beispiel geben:

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>

Wie Sie hier sehen, ist es sogar möglich, eine Bean außerhalb des Interfaces zu erstellen! Es ist jedoch keine Schnittstelleninjektion, da der IoC-Contener die Instanse dieser Bean von sich aus initialisiert. Mit anderen Worten, card bean ist ein initialisiertes Objekt, keine Schnittstelle. Daher ist die ausgewählte Antwort für diese Frage richtig. 

1
Tinki

Ich glaube, jemand hat Ihre Fragen beantwortet hier Ich wusste auch nicht, was Interface Injection ist, bis ich diese Aussage aus "Pro Spring MVC mit Web Flow Book" gelesen habe 

"Beachten Sie, dass die Schnittstellen-basierte Abhängigkeitsinjektion vom Spring Framework nicht unterstützt wird. Dies bedeutet, dass wir angeben müssen, welche konkrete Implementierung für eine bestimmte Schnittstelle eingefügt werden soll." 

1
Adelin