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

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 acoplamiento flexible 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 constructor

En la Inyección de Constructor, la Inyección de Dependencia se inyectará con la ayuda de constructores. Ahora, para configurar la Inyección de dependencia como Inyección de dependencia del constructor en el bean, se realiza a través del archivo de configuración del bean. Para ello, la propiedad que se establecerá con el CDI se declara bajo la etiqueta <constructor-arg> 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í.

Archivo : Student.java

public class Student 
{
    // Class data members
    private int id;
    private MathCheat mathCheat;

    // Method
    public void cheating() 
    {

        System.out.println("My ID is: " + id);

        mathCheat.mathCheating();
    }

}

Archivo : MathCheat.java

public class MathCheat 
{
    public void mathCheating() 
    {
        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 Inyección de Dependencia del Constructor. Primero, tenemos que crear el constructor dentro del archivo Student.java . Ahora el archivo Student.java es algo como esto.

// Java Program to Illustrate Student class
 
public class Student {
 
    // Class data members
    private int id;
    private MathCheat mathCheat;
 
    // Constructor of Student class
    public Student(int id, MathCheat mathCheat)
    {
        this.id = id;
        this.mathCheat = mathCheat;
    }
 
    // Method
    public void cheating()
    {
        System.out.println("My ID is: " + id);
        mathCheat.mathCheating();
    }
}

Lo único que necesitamos cambiar es el archivo beans.xml. 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 <constructor-arg> en lugar de la etiqueta <property>, así

Sintaxis: Estándar 

<bean id="AnyUniqueId" class="YourClassName">
  <constructor-arg name="attributes that you have defined in your class" value="And its corresponding values"/>
</bean>

Por ejemplo: Para este proyecto, podemos escribir algo como esto

<bean id="student" class="Student">
    <constructor-arg name="id" value="101"/>
    <constructor-arg name="mathCheat">
       <bean class="MathCheat"></bean>
    </constructor-arg>
</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">
        <constructor-arg name="id" value="101"/>
        <constructor-arg name="mathCheat">
            <bean class="MathCheat"></bean>
        </constructor-arg>
    </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 para el archivo Main.java.

Archivo de solicitud 

// Java Program to Illustrate Application Class
 
// Importing required classes
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
 
// Application class
// GFG class
public class Main {
 
    // Main driver method
    public static void main(String[] args)
    {
 
        // Implementing Spring IoC
        // Using ApplicationContext
        ApplicationContext context
            = new ClassPathXmlApplicationContext(
                "beans.xml");
 
        // Getting the bean student
        Student student
            = context.getBean("student", Student.class);
 
        // Calling the method inside main() 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">
    <constructor-arg name="id" value="101"/>
    <constructor-arg name="mathCheat" ref="mathCheatObjectValue"/>
</bean>

A continuación se muestra el código completo del archivo beans.xml .

Ejemplo:

<?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">
         <constructor-arg name="id" value="101"/>
         <constructor-arg name="mathCheat" ref="mathCheatObjectValue"/>
    </bean>
 
</beans>

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