java - tutorial - inyeccion sql youtube
Ejemplo de inyección de interfaz de resorte (7)
Hasta el momento, nadie era capaz de proporcionar un ejemplo correcto de inyección de interfaz en Spring Framework. El artículo de Martin Fowler no es para mortales, todo lo demás son palabras colocadas de una manera muy confusa. He navegado por treinta artículos, donde la gente dice "Spring no soporta directamente la inyección de interfaz" ("y porque no sé exactamente cómo describiré las inyecciones del constructor y el constructor") o bien "Lo discutiré en mi otros subprocesos "o bien habrá algunos comentarios a continuación que digan que es un ejemplo incorrecto. No pido explicaciones, BEG por ejemplo.
Hay tres tipos de inyección: Constructor, Setter e Interfaz. Spring no soporta lo último directamente (como he observado decir a la gente). Entonces, ¿cómo se hace exactamente?
Gracias,
Con la inyección de interfaz, una interfaz define explícitamente el punto donde se puede establecer una dependencia:
interface InjectPerson {
public void injectHere(Person p);
}
class Company implements InjectPerson {
Person injectedPerson;
public void injectHere(Person p) {
this.injectedPerson = p;
}
}
Creo que alguien respondió a sus preguntas here . Tampoco sabía qué es la inyección de interfaz hasta que leí esta declaración del "Pro Spring MVC with web flow book".
"Tenga en cuenta que Spring Framework no admite la inyección de dependencia basada en la interfaz. Esto significa que debemos especificar qué implementación concreta se debe inyectar para una interfaz determinada".
Creo que la confusión en torno a la inyección de interfaz se debe a una mala interpretación de lo que realmente significa el término "inyección de interfaz". En mi entendimiento, la inyección de interfaz describe la capacidad de un contenedor de bean para inyectar una nueva interfaz en el bean, sin importar que la definición de clase de este bean no lo implemente.
Todos los ejemplos presentados aquí muestran cómo crear un bean de una clase concreta y luego cómo inyectarlo en otro bean. El hecho de que en todos los casos el bean se inyecte en un campo definido como una interfaz no importa, todas las operaciones se realizan con beans creados a partir de instancias concretas.
Puedo proporcionar también otro ejemplo pegadizo:
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í, incluso es posible crear un bean fuera de la interfaz! Aún así, no es una inyección de interfaz, ya que IoC el contenedor 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.
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).
Spring soporta solo inyecciones basadas en constructor y colocador. Parece que te confundiste con los diferentes tipos (3) y lo que Spring admite (2 de ellos).
Hola, lo intenté con un enfoque muy simple que puede aclarar tu respuesta.
A continuación se muestra el código que he construido utilizando dos interfaces y dos clases de beans.
Primera interfaz con el nombre de trabajo.
public interface Job {
public void setmyJob(String myJob);
public String getmyJob();
}
y una clase para implementar esta interfaz con nombre como 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 creé otra Interfaz con nombre como Servicio
public interface Service {
public void setJob(Job job);
public Job getJob();
}
y luego otra clase para 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;
}
}
Luego creé en la clase principal con la función principal y escribí el código 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 mencioné el código siguiente 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 luego obtuve este tipo de solución. Por favor, avíseme si tiene algún problema con este código. esta funcionando para mi
Por favor revise el siguiente ejemplo para la inyección iterface.
Hay una interfaz de forma y 2 clases concretas que se complementan con forma cuadrada y rectangular.
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();
}
}
Según Variantes de DI en primavera.
DI existe en dos variantes principales: inyección de dependencia basada en constructor e inyección de dependencia basada en Setter.
También ver la inyección de interfaz no está implementada en Spring lo indica claramente.
Así que solo hay dos variantes de DI. Entonces, si la documentación no dice nada sobre la inyección de interfaz, está claro que no está allí. Aquellos que creen que la inyección de la interfaz se realiza proporcionando un método de establecimiento en la interfaz me responden:
- ¿Por qué Spring Ref Doc dejó mención de la interfaz de inyección?
- ¿Por qué no se puede interconectar la inyección a través del método de establecimiento de setter NO considerado como la propia inyección de setter? ¿Por qué crear un término especial para eso cuando la introducción de la interfaz no afecta nada, me refiero a que todavía está configurado de la misma manera. Si fueran diferentes, entonces, ¿cómo se puede encontrar a través de ver la configuración? ¿No debería ser transparente que en la configuración y no ver el implemento que la clase realmente configurada implementa alguna interfaz?
- Al igual que la creación de instancias utilizando un método de fábrica de instancia y la creación de instancias utilizando un método de fábrica estática , algunos atributos de bean deben aclarar la inyección de la interfaz.