Primavera – Inyección de dependencia por método Setter

La inyección de dependencia es la funcionalidad principal proporcionada por Spring IOC (Inversion of Control). El módulo Spring-Core es responsable de inyectar dependencias a través de los métodos Constructor o Setter. El principio de diseño de Inversion of Control hace hincapié en mantener las clases de Java independientes entre sí y el contenedor las libera de la creación y el mantenimiento de objetos. Estas clases, administradas por Spring, deben cumplir con la definición estándar de Java-Bean. La inyección de dependencia en Spring también asegura un acoplamiento flexible entre las clases.

Necesidad de inyección de dependencia

Supongamos que la clase Uno necesita el objeto de la clase Dos para instanciar u operar un método, entonces se dice que la clase Uno depende de la clase Dos. Ahora, aunque puede parecer correcto depender de un módulo del otro, pero en el mundo real, esto podría generar muchos problemas, incluida la falla del sistema. Por lo tanto, tales dependencias deben evitarse. Spring IOC resuelve tales dependencias con Dependency Injection , lo que hace que el código sea más fácil de probar y reutilizar. El acoplamiento flexible entre clases puede ser posible mediante la definición de interfaces para una funcionalidad común y el inyector instanciará los objetos de la implementación requerida. La tarea de crear instancias de objetos la realiza el contenedor de acuerdo con las configuraciones especificadas por el desarrollador.

Tipos de inyección de dependencia de resorte

Hay dos tipos de Spring Dependency Injection. Están: 

• Setter Dependency Injection (SDI): Este es el más simple de los dos métodos DI. En esto, el DI se inyectará con la ayuda de métodos setter y/o getter. Ahora, para establecer el DI como SDI en el bean, se hace a través del archivo de configuración del bean. Para esto, la propiedad que se establecerá con el SDI se declara bajo la etiqueta <property> en el archivo bean-config.
• Inyección de dependencia del constructor (CDI): en esto, el DI se inyectará con la ayuda de constructores. Ahora, para establecer el DI como CDI en el bean, se hace a través del archivo de configuración del bean. Para esto, la propiedad que se establecerá con el CDI se declara bajo la etiqueta <constructor-arg> en el archivo bean-config.

Inyección de dependencia por método Setter con ejemplo

La inyección Setter es una inyección de dependencia en la que Spring Framework inyecta el objeto de dependencia utilizando el método Setter. La llamada va primero al constructor sin argumentos y luego al método setter. No crea ninguna nueva instancia de bean. Veamos un ejemplo para inyectar dependencia por el método setter.

1. Empleado.java (clase POJO)
2. config.xml 
3. Principal.java

1. Archivo empleado.java

package com.spring;
  
public class Student {
    
    private String studentName;
    private String studentCourse;
  
    public String getStudentName() 
    { 
      return studentName;
    }
  
    public void setStudentName(String studentName)
    {
        this.studentName = studentName;
    }
  
    public String getStudentCourse()
    {
        return studentCourse;
    }
  
    public void setStudentCourse(String studentCourse)
    {
        this.studentCourse = studentCourse;
    }
  
    @Override public String toString()
    {
        return "Student{"
            + "studentName=" + studentName + 
             ", studentCourse=" + studentCourse + '}';
    }
}

2. Archivo config.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"
 xmlns:context="http://www.springframework.org/schema/context"
 xsi:schemaLocation="http://www.springframework.org/schema/beans
                      https://www.springframework.org/schema/beans/spring-beans.xsd
                     http://www.springframework.org/schema/context
                      http://www.springframework.org/schema/context/spring-context.xsd">
    
     <bean class="com.springframework.Student" name="stud">
   
       <property name="studentName">
               <value> John </value> 
       <property/>
  
       <property name="studentCourse">
               <value> Spring Framework </value> 
          <property/>
  
    </bean>
    
</beans>

3. Archivo principal.java

package com.spring;
  
import java.io.*;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationCotenxt;
  
public class GFG {
    public static void main(String[] args)
    {
        ApplicationContext context = new ClassPathXmlApplicationCotenxt("config.xml");
        Student student= (Student)context.getBean("stud");
        System.out.println(student);
    }
}

Producción:

Student{ studentName= John  , studentCourse= Spring Framework }