Primavera – Inyección de objetos por inyección Setter

Spring IoC (Inversion of Control) Container es el núcleo de Spring Framework . Crea los objetos, configura y ensambla sus dependencias, gestiona todo su ciclo de vida. El Contenedor utiliza Inyección de Dependencia (DI) para administrar los componentes que componen la aplicación. Obtiene la información sobre los objetos de un archivo de configuración (XML) o Java Code o Java Annotations y Java POJO class. Estos objetos se llaman Beans. Dado que los desarrolladores no controlan los objetos Java y su ciclo de vida, de ahí el nombre Inversion Of Control. Las siguientes son algunas de las características principales de Spring IoC,

• Creando Objeto para nosotros,
• Administrar nuestros objetos,
• Ayudando a que nuestra aplicación sea configurable,
• Administrar dependencias

Inyección de dependencia de primavera

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 bajo acoplamiento entre las clases. Hay dos tipos de Spring Dependency Injection.

• Inyección de dependencia del setter (SDI)
• Inyección de dependencia del constructor (CDI)

Para leer más sobre la inyección de dependencia de Spring, consulte este artículo: Inyección de dependencia de Spring con ejemplo

Inyección de Setter

Setter Injection es el más simple de los dos métodos de inyección de dependencia. En esto, la inyección de dependencia se inyectará con la ayuda de métodos setter y/o getter. Ahora, para establecer la Inyección de Dependencia como Inyección Setter en el bean, se hace a través del archivo bean-configuration. Para esto, la propiedad que se establecerá con la Inyección Setter se declara bajo la etiqueta <property> en el archivo bean-config.

Entonces, en este artículo, aprendamos cómo vamos a usar Spring para inyectar nuestras dependencias en nuestros valores de objeto mediante Setter Injection. El objeto es una unidad básica de la programación orientada a objetos y representa entidades de la vida real. Entonces, generalmente en Java, creamos objetos de una clase usando la nueva palabra clave.

Test t = new Test();
// creating object of class Test
// t is the object

Implementación: supongamos que tenemos una clase llamada «Estudiante» y dentro de la clase, queremos inyectar el objeto de otra clase llamada «MathCheat». Y también hay un método presente dentro de la clase llamado «hacer trampa()», algo así.

Ejemplo 1:

// Java Program to Illustrate Student File
 
// Class
public class Student {
 
    // Attributes
    private int id;
    private MathCheat mathCheat;
 
    // Method
    public void cheating()
    {
        System.out.println("My ID is: " + id);
        mathCheat.mathCheating();
    }
}

Ejemplo 2:

// Java Program to Illustrate MathCheat File
 
// Class
public class MathCheat {
 
    // Method
    public void mathCheating()
    {
        // Print statement
        System.out.println(
            "And I Have Stated Math Cheating");
    }
}

Así que ahora queremos inyectar el objeto de MathCheat en la clase Student usando el concepto de Setter Dependency Injection. Primero, tenemos que crear el método setter dentro del archivo Student.java . Ahora el archivo Student.java es algo como esto.

Ejemplo 1:

// Java Program to Illustrate Student File
 
// Class
public class Student {
 
    // Attributes
    private int id;
    private MathCheat mathCheat;
 
    // Setter
    public void setId(int id) { this.id = id; }
 
    // Setter
    public void setMathCheat(MathCheat mathCheat)
    {
        this.mathCheat = mathCheat;
    }
 
    // Method
    public void cheating()
    {
 
        // Print statement
        System.out.println("My ID is: " + id);
       
        mathCheat.mathCheating();
    }
}

Ahora vamos a crear un Student Bean en el archivo beans.xml y dentro del bean, debe agregar el nombre de su propiedad y sus valores correspondientes dentro de la etiqueta <property>, así

Sintaxis: Estándar 

<bean id="AnyUniqueId" class="YourClassName">

  <property name="attributes that you have defined 
  in your class" value="And its corresponding values"/>
  
</bean>

Pero aquí estamos inyectando objetos, no valores literales como hemos hecho en este artículo Inyección de valores literales por inyección de Setter. Entonces, para este ejemplo, podemos escribir algo como esto

<bean id="student" class="Student">
      <property name="id" value="101"/>
      <property name="mathCheat">
        <bean class="MathCheat"></bean>
      </property>
</bean>

Puede ver cómo creamos el bean de la clase MathCheat dentro del bean Student. A continuación se muestra el código completo para el archivo beans.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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       https://www.springframework.org/schema/beans/spring-beans.xsd">
 
    <bean id="student" class="Student">
        <property name="id" value="101"/>
        <property name="mathCheat">
            <bean class="MathCheat"></bean>
        </property>
    </bean>
 
</beans>

Entonces, para probar esto, creemos un método principal y llamemos al método cheating() dentro de la clase Student. A continuación se muestra el código del archivo Main.java.

Ejemplo

// Java Program to Illustrate Main File
// Implementing Spring IoC
 
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
 
// Main class
public class Main {
 
    // Main driver method
    public static void main(String[] args)
    {
 
        // Using ApplicationContext to
        // Implementing Spring IoC
        ApplicationContext context
            = new ClassPathXmlApplicationContext(
                "beans.xml");
 
        // Getting the bean student
        Student student
            = context.getBean("student", Student.class);
 
        // Calling the method
        student.cheating();
    }
}

Producción:

My ID is: 101
And I Have Stated Math Cheating

Otro enfoque (enfoque correcto)

Entonces, hay otro enfoque para crear el bean de la clase MathCheat dentro del archivo beans.xml. Entonces puedes escribir algo como esto usando la » ref «. 

<bean id="mathCheatObjectValue" class="MathCheat"></bean>

<bean id="student" class="Student">
    <property name="id" value="101"/>
    <property name="mathCheat" ref="mathCheatObjectValue"/>
</bean>

A continuación se muestra el código completo del archivo beans.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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       https://www.springframework.org/schema/beans/spring-beans.xsd">
     
    <bean id="mathCheatObjectValue" class="MathCheat"></bean>
 
    <bean id="student" class="Student">
         <property name="id" value="101"/>
         <property name="mathCheat" ref="mathCheatObjectValue"/>
    </bean>
 
</beans>

Entonces, cada vez que vaya a ejecutar su aplicación, obtendrá el mismo resultado.