Ejemplo de inyección de interfaz de resorte

Question

Hasta ahora, nadie era capaz de proporcionar un ejemplo correcto de funcionamiento de inyección de interfaz en Spring Framework. El artículo de Martin Fowler no es para los mortales, todo lo demás simplemente palabras colocadas de una manera muy confusa. He navegado por TREINTA artículos, donde las personas dicen "Spring doesnt supports supports for interface injection" ("y porque no sé exactamente cómo describiré las inyecciones de setter y constructor") o bien "Discutiré en mi otros hilos "o bien habrá pocos comentarios a continuación diciendo que es un ejemplo erróneo. No pido explicaciones, BEG, por ejemplo.

Hay tres tipos de inyección: Constructor, Setter e Interface. Spring no admite la última directamente (como he observado que dicen las personas). Entonces, ¿cómo se hace exactamente?

gracias,

Answer 1

Según Variants of DI in spring

DI existe en dos variantes principales, la inyección de dependencia basado en constructor y de inyección de dependencias basada en Setter.

Véase también Interface injection is not implemented in Spring establece claramente.

Por lo tanto, solo hay dos variantes de DI. Por lo tanto, si la documentación no dice nada acerca de la inyección de interfaz, es claro que no está ahí. Los que creen que la inyección de interfaz la realiza el proveedor Método setter en la interfaz respóndeme:

1. ¿Por qué spring ref doc dejó mención de interfaz injection?
2. Por qué no se puede interconectar la inyección a través del método setter NOT que se considera como inyección setter. ¿Por qué crear un término especial para eso cuando la introducción de la interfaz no afecta nada, quiero decir que todavía está configurado de la misma manera. Si fueran diferentes, ¿cómo puede uno encontrarlo viendo la configuración? ¿No debería ser transparente que en config y no ver la impl que la clase realmente configurada implemente alguna interfaz?
3. Al igual que Instantiation using an instance factory method y Instantiation using an static factory method, algunos atributos del bean deben aclarar la inyección de la interfaz?

Answer 2

Con la inyección de interfaz de una interfaz define explícitamente el punto en el que una dependencia se puede configurar:

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

class Company implements InjectPerson { 
    Person injectedPerson; 

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

Answer 3

Hola me trató con un enfoque muy simple que puede aclarar su respuesta.

siguiente es el código que he creado utilizando dos interfaces y dos clases de bean.

primera interfaz con el nombre Job.

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

y una clase para implementar esta interfaz con el nombre que 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; 
    } 
} 

En el siguiente paso que he creado otra interfaz con el nombre como Servicio

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

y de nuevo otra clase de implementar esta interfaz de servicio.

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

Entonces creé en clase principal con la función principal y el código escrito de la siguiente manera:

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

en mi archivo beans.xml he mencionado el código de la siguiente manera y funcionó.

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

También me he referido a otros tutoriales en línea y obtuve este tipo de solución. por favor avíseme si tiene algún problema con este código. está trabajando para mí.

Answer 4

Creo que alguien respondió a sus preguntas here Yo tampoco sabía lo que es la inyección de interfaz hasta que leí esta declaración de "Pro Spring MVC con el libro flujo de web"

"Tenga en cuenta que ISN inyección de dependencias basada en la interfaz No es compatible con Spring Framework. Esto significa que tenemos que especificar qué implementación concreta inyectar para una determinada interfaz."

Answer 5

Hay 3 tipos de inyecciones de dependencia: -

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

resorte soporta único constructor y setter de inyección basado. Parece que te confundieron los diferentes tipos (3) y lo que la primavera admite (2 de ellos).

Answer 6

Por favor, compruebe el ejemplo siguiente para la inyección en la cara.

Hay una interfaz de forma y 2 clases de hormigón con forma de imponentes, es decir, cuadrados y rectangulares.

La interfaz

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

2 clases implementadas

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

} 

Ahora, tenemos una clase que establece la forma.

public class ShapeSetter { 

    private Shape shape; 

    public Shape getShape() { 
     return shape; 
    } 

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

} 

y, finalmente, la configuración

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

Aquí,

estamos inyectando diferentes formas.

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

creo, que la confusión en torno a la inyección interfaz es causada por malentendido lo que el término "inyección de interfaz" significa en realidad. Según entiendo, la inyección de interfaz describe la capacidad de un bean contener para inyectar una nueva interfaz al bean, sin importar que la definición de clase de este bean no lo esté implementando.

Todos los ejemplos presentados aquí muestran cómo crear un grano de clase concreta, y luego cómo inyectar en otro bean. El hecho de que, en todos los casos, Bean se inyecte en un campo definido como interfaz, no importa; todas las operaciones se realizan con beans creados a partir de instancias concretas.

puedo proporcionar también otro ejemplo pegadiza:

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> 

Como se ve aquí, es incluso posible la creación de un grano de interfaz! Aún así, no es una inyección de interfaz, ya que IoC contiene inicializa el instanse de este bean por sí mismo. En otras palabras, card bean es un objeto inicializado, no una interfaz, lo que hace que la respuesta seleccionada para esta pregunta sea correcta.