Exemple d'injection de l'interface à ressort

avec injection d'interface une interface définit explicitement le point où une dépendance peut être définie:

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

class Company implements InjectPerson {
   Person injectedPerson; 

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

Salut, j'ai essayé avec une approche très simple qui peut clarifier votre réponse.

voici le code sur lequel j'ai construit en utilisant deux interfaces et deux classes bean.

première interface avec le nom Travail.

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

et une classe pour mettre en œuvre cette interface avec le nom comme 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;
    }
}

dans la prochaine étape j'ai créé une autre Interface avec le nom comme Service

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

et puis encore une autre classe pour mettre en œuvre cette Interface de Service.

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

, puis j'ai créé sur la classe principale avec la fonction principale et écrit le code comme suit:

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

dans mes haricots.fichier xml, j'ai mentionné le code comme suit et il a travaillé.

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

j'ai aussi reffered à un autre tutoriels en ligne et puis obtenu ce genre de solution. s'il vous plaît laissez-moi savoir si vous avez un quelconque problème avec cette code. il est travaillé pour moi.

je pense que quelqu'un a répondu à vos questions ici Je ne savais pas non plus ce qu'était L'injection D'Interface jusqu'à ce que je lise cette déclaration de "Pro Spring MVC with web flow book "

" notez que l'injection de dépendance basée sur l'interface n'est pas supportée par le cadre de ressort. Ce signifie que nous devons spécifier quelle implémentation concrète injecter pour une certaine interface."

il y a 3 types d'injections de dépendance: -

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

ne supporte que l'injection basée sur le constructeur et le setter. On dirait que vous avez été confus dans les différents types(3) et quels supports de ressort (2 d'entre eux).

veuillez cocher l'exemple ci-dessous pour l'injection iterface.

il y a une interface de forme et deux classes de béton qui imiplements forme à savoir carré et rectangle.

l'interface

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

2 classes appliquées

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

}

Maintenant, nous avons une classe qui définit la forme.

public class ShapeSetter {

    private Shape shape;

    public Shape getShape() {
        return shape;
    }

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

}

et enfin la configuration

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

ici,

nous injectons différentes formes.

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

}

je pense que la confusion autour de l'injection d'interface est causée par une mauvaise compréhension de ce que le terme" injection d'interface " signifie réellement. Dans ma compréhension, l'injection d'interface décrit la capacité d'un conteneur de haricot d'injecter une nouvelle interface à la fève, peu importe que la définition de classe de cette fève n'est pas mise en œuvre.

tous les exemples présentés ici montrent comment créer un haricot à partir d'une classe de béton, puis comment l'injecter dans un autre haricot. Le le fait que, dans tous les cas, la fève soit injectée dans un champ défini comme interface n'a pas d'importance - toutes les opérations sont effectuées avec des fèves créées à partir d'instances concrètes.

je peux fournir aussi un autre exemple accrocheur:

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>

comme vous le voyez ici, il est même possible de créer un haricot hors de l'interface! Néanmoins, il ne s'agit pas d'une injection d'interface, car IOC contener initialise instanse de cette fève par ses propres. En d'autres termes, card haricot est une objet initialisé, pas une interface, ce qui rend, que la réponse choisie pour cette question est correcte.